C ++ Map Toi par clé

Une carte se compose de paires de clés / valeur. Chaque paire est un élément. Toutes les clés d'une carte sont uniques. Une carte peut être triée par des clés. Le tri peut s'arrêter ou descendre. Ascendant est la valeur par défaut. Le tri sur une carte n'est pas toujours simple. Il a besoin d'un objet de fonction de comparaison. Si l'objet de comparaison est ignoré, le tri par défaut a lieu.

Si les clés sont des pointeurs constantes sur les caractères, la carte est triée par les pointeurs clés, et non par les littéraux de cordes clés. Ce n'est guère ce que quiconque veut. Considérez les paires de clés / valeur suivantes de fruits et leurs couleurs extérieures:

"prune" => "violet"
"BlackBerry" => "Blue foncé-noir"
"pastèque" => "vert"
"abricot", => "orange"
"papaya" => "orange"
"banane" => "jaune"

Les fruits sont les clés et les couleurs sont les valeurs. Cette liste d'éléments (paires de clés / valeur) n'est pas triée. Le programme suivant crée une carte de cette liste telle qu'elle est et l'affiche telle qu'elle est, non triée par des littéraux de cordes:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

carte MP;
mp ["plum"] = "violet";
MP ["BlackBerry"] = "Dark Blue-Black";
MP ["pastèque"] = "vert";
mp ["abricot"] = "orange";
mp ["Papaya"] = "Orange";
mp ["banane"] = "jaune";
pour (carte:: iterator it = MP.commencer(); il != MP.fin(); it ++)
couter << it->d'abord << " => " << it->deuxième << endl;
retour 0;

La sortie est:

prune => violet
BlackBerry => noir bleu foncé
pastèque => vert
abricot => orange
Papaya => Orange
banane => jaune

Non trié par les littéraux de cordes, mais trié par des pointeurs. Pour utiliser une carte dans un programme C ++, la bibliothèque de cartes doit être incluse avec une directive inclue.

Une autre façon de créer la carte simple ci-dessus est la suivante:

#inclure
#inclure
Utilisation de Namespace Std;
int main()

carte MP ("Plum", "Purple", "BlackBerry", "Dark Blue-Black", "Watermelon", "Green", "abricot", "Orange", "Papaya" , "orange", "banane", "jaune");
pour (carte:: iterator it = MP.commencer(); il != MP.fin(); it ++)
couter << it->d'abord << " => " << it->deuxième << endl;
retour 0;

La sortie est:

prune => violet
BlackBerry => noir bleu foncé
pastèque => vert
abricot => orange
Papaya => Orange
banane => jaune

Non trié par des littéraux de cordes, bien que triés par des pointeurs. Si les clés étaient entiers, la sortie aurait été triée par des clés. En pratique, les clés de nombreuses cartes sont des littéraux à cordes. Cet article explique comment les clés des littéraux de cordes peuvent trier une carte.

Contenu de l'article

• Trié pendant la création
• Produire une gamme descendant
• Comparaison de deux éléments par clé
• Tri de la carte créée avec la liste des initialisateurs
• Conclusion

Trier pendant la création

Le modèle complet pour la construction de la carte est:

modèle, Class Allocator = Allocator>> Map de classe;

Les classes, comparer et allocator, ont des valeurs par défaut. Autrement dit, ils ont une spécialisation par défaut, qui n'a pas besoin d'être tapée dans les déclarations de carte (instanciations). Ce qui est intéressant ici, c'est la classe de comparaison. Le nom de la classe est compare, et la spécialisation par défaut est «moins». "moins

Une carte est normalement créée triée par des clés pendant la création. Si les clés sont const char *, alors les pointeurs vers les chaînes littérales citées seront triées, pas les textes littéraux. Pour que les chaînes soient triées pendant la création, les chaînes doivent être des littéraux d'objets de chaîne instanciés de la classe de chaîne. Cela signifie que la bibliothèque de chaînes doit être incluse, ainsi que la bibliothèque de cartes.

Création

Dans le programme suivant, la carte est créée, triée ascendante:

#inclure
#inclure
#inclure
Utilisation de Namespace Std;
int main()

carte> MP;
mp ["plum"] = "violet";
MP ["BlackBerry"] = "Dark Blue-Black";
MP ["pastèque"] = "vert";
mp ["abricot"] = "orange";
mp ["Papaya"] = "Orange";
mp ["banane"] = "jaune";
pour (carte:: iterator it = MP.commencer(); il != MP.fin(); it ++)
couter << it->d'abord << " => " << it->deuxième << endl;
retour 0;

La sortie est:

abricot => orange
banane => jaune
BlackBerry => noir bleu foncé
Papaya => Orange
prune => violet
pastèque => vert

Même si moins étaient omis du modèle, le tri aurait toujours été montré parce que moins est la valeur par défaut.

Création descendant

Afin de créer une carte, de sorte qu'elle est triée dans l'ordre descendant par les clés, la spécialisation compare doit être codée. Le programme suivant illustre ceci:

#inclure
#inclure
#inclure
Utilisation de Namespace Std;
int main()

carte> MP;
mp ["plum"] = "violet";
MP ["BlackBerry"] = "Dark Blue-Black";
MP ["pastèque"] = "vert";
mp ["abricot"] = "orange";
mp ["Papaya"] = "Orange";
mp ["banane"] = "jaune";
pour (carte:: iterator it = MP.commencer(); il != MP.fin(); it ++)
couter << it->d'abord << " => " << it->deuxième << endl;
retour 0;

La sortie est:

pastèque => vert
prune => violet
Papaya => Orange
BlackBerry => noir bleu foncé
banane => jaune
abricot => orange

Produire une gamme descendant

Une gamme d'une carte peut être produite par ordre décroissant. Cela implique la création d'une deuxième carte, qui est une plage de la première carte. Le programme suivant illustre ceci:

#inclure
#inclure
#inclure
Utilisation de Namespace Std;
int main()

carte MP;
mp ["plum"] = "violet";
MP ["BlackBerry"] = "Dark Blue-Black";
MP ["pastèque"] = "vert";
mp ["abricot"] = "orange";
mp ["Papaya"] = "Orange";
mp ["banane"] = "jaune";
carte:: iterator itb = mp.commencer();
itb ++;
carte:: iterator ite = mp.fin();
ite--;
carte> MPR (ITB, ITE);
pour (carte:: iterator it = MPR.commencer(); il != MPR.fin(); it ++)
couter << it->d'abord << " => " << it->deuxième << endl;
retour 0;

La sortie est:

prune => violet
Papaya => Orange
BlackBerry => noir bleu foncé
banane => jaune

Le premier objet MAP a six éléments qui sont:

abricot => orange
banane => jaune
BlackBerry => noir bleu foncé
Papaya => Orange
prune => violet
pastèque => vert

La plage considérée est:

banane => jaune
BlackBerry => noir bleu foncé
Papaya => Orange
prune => violet
pastèque => vert

Dans le code, "ITB ++" pointe vers "banane", "jaune" et "ite-" pointe "pastèque", "vert" pour la gamme. Lors de la gestion d'une plage en C ++, l'élément final n'est pas impliqué dans la manipulation. Et donc la production a quatre éléments avec "Paserme", "Green" omis.

La spécialisation du paramètre de modèle de comparaison de la deuxième carte est plus grande. S'il était moins ou omis, la plage aurait entraîné l'ordre croissant.

Comparaison de deux éléments par clé

key_compare key_comp () const

Cette fonction membre renvoie une copie de l'objet de comparaison utilisé par le conteneur de carte pour comparer les clés. Un objet de comparaison est un objet de fonction. Il faudrait deux clés comme arguments et reviendrait vrai si la clé de gauche est inférieure à droite. Avec cela, le segment de code doit être:

key_compare kc = MP.key_comp ();
bool bl = kc ("pastèque", "abricot");

key_compare n'est pas reconnu par le compilateur. Éliminer Key_Compare dans ce segment de code, en substituant à KC dans la deuxième instruction, se traduit:

bool bl = MP.key_comp () ("pastèque", "abricot");

Le programme suivant illustre l'utilisation de key_comp ().

#inclure
#inclure
#inclure
Utilisation de Namespace Std;
int main()

carte MP;
mp ["plum"] = "violet";
MP ["BlackBerry"] = "Dark Blue-Black";
MP ["pastèque"] = "vert";
mp ["abricot"] = "orange";
mp ["Papaya"] = "Orange";
mp ["banane"] = "jaune";
bool bl = MP.key_comp () ("pastèque", "abricot");
couter << bl << endl;
retour 0;

La sortie est 0 pour false.

Le vrai problème avec le segment de code ci-dessus est que l'espace de noms pour key_compare, n'était pas bien exprimé. Si le segment était,

carte:: key_compare kc = mp =.key_comp ();
bool bl = kc ("pastèque", "abricot");

Cela aurait fonctionné (accepté par le compilateur).

Value_Compare Value_Comp () const

Cette fonction membre est similaire à Key_Comp (). Remarque: Ici, ce n'est pas la valeur de la paire clé / valeur qui est mentionnée; c'est l'élément de la paire de clés / valeur. Ainsi, les deux arguments pour l'objet de fonction Value_Compare sont des éléments d'itérateur. Le programme suivant utilise Value_Comp (), en comparant les premier et derniers éléments, «abricot», «orange» et «pastèque», «vert»:

#inclure
#inclure
#inclure
Utilisation de Namespace Std;
int main()

carte> MP;
mp ["plum"] = "violet";
MP ["BlackBerry"] = "Dark Blue-Black";
MP ["pastèque"] = "vert";
mp ["abricot"] = "orange";
mp ["Papaya"] = "Orange";
mp ["banane"] = "jaune";
carte:: iterator itb = mp.commencer();
carte:: iterator ite = mp.fin();
ite--;
carte:: Value_Compare VC = MP.value_comp ();
bool bl = vc (* itb, * ite);
couter << bl << endl;
retour 0;

La sortie est 1, pour vrai. Les itérateurs ITB et ITE ont été déréférencés d'avoir leurs éléments, avec l'opérateur d'indirection.

Tri de la carte créée avec la liste des initialisateurs

Dans le programme suivant, où le tri descendant, les touches sont des objets de chaîne, instanciés à partir de la classe de chaîne:

#inclure
#inclure
#inclure
Utilisation de Namespace Std;
int main()

carte> MP ("Plum", "Purple", "BlackBerry", "Dark Blue-Black", "Pasermelon", "Green", "abricot", "Orange", "Papaya "," orange ", " banane "," jaune ");
pour (carte:: iterator it = MP.commencer(); il != MP.fin(); it ++)
couter << it->d'abord << " => " << it->deuxième << endl;
retour 0;

La sortie est:

pastèque => vert
prune => violet
Papaya => Orange
BlackBerry => noir bleu foncé
banane => jaune
abricot => orange

Conclusion

Une carte est créée triée par des clés, ascendante. Ascendant est l'ordre par défaut. Pour le faire descendre, ajoutez la spécialisation des paramètres du modèle, plus grande comme troisième argument, dans la liste d'argument du modèle. Remarque: si les touches sont des chaînes, elles doivent être instanciées de la classe de chaîne, comme illustré ci-dessus. Les touches de cordes en tant que const-char * ou char-arr [], se retrouvent avec leurs pointeurs triés et non leurs littéraux.