Comment utiliser des cartes en C ++

La carte C ++ est une structure de données de liste avec des paires de clés / valeur. Une structure de données a des fonctions membres. En C ++, il y a une carte et il y a un non ordonné_map. La carte est en fait une carte commandée. La commande pour la carte peut s'arrêter ou descendre par des clés. La valeur par défaut est l'ordre croissant par les clés. Les fonctionnalités de la carte commandée et de la carte non ordonnée sont tellement dans la mesure où seuls ceux de la carte (i.e., Carte commandée) sera considérée dans cet article.

Les fonctionnalités de la carte peuvent être classées en construction, accès aux éléments, capacité, itérateurs, modificateurs, observateurs, opérations et algorithmes spécialisés. Il arrive également que les fonctionnalités de la carte sont nombreuses. Ainsi, seules les fonctions de base de ces catégories seront expliquées.

Un exemple de liste de paires de clés / valeur est la liste suivante des fruits et leurs couleurs communes de la peau mûre:

BlackBerry => noir bleu foncé
mangue => jaune
Fruit de la passion => violet
prune => violet
banane => jaune

Les chaînes à gauche de la liste forment les clés; Ceux de la bonne forme sont les valeurs. Les paires de clé / valeur ne doivent pas nécessairement être de chaîne / chaîne. Il peut être d'int / string, de chaîne / float, int / float, etc. Dans une carte C ++, une paire de clés / valeur est un élément, et ces éléments forment la liste des structures de données. Une structure de données de carte fournit une récupération rapide des données basées sur les clés. Les clés sont uniques et la structure de la carte est plusieurs à un. Cela signifie que les valeurs peuvent avoir des doublons, mais les clés ne peuvent pas.

Afin d'utiliser la bibliothèque Map dans un programme C ++, le programme devrait commencer par quelque chose comme:

#inclure
#inclure
Utilisation de Namespace Std;

Si les chaînes font partie de la carte, l'utilisation de #include au lieu de sera recommandée. Cet article explique comment utiliser une carte C ++.

Contenu de l'article

• Construction / destruction
• CONSTRUCTION ET ADMISSANCE
• Affichage du contenu de la carte (impression)
• Accès à l'élément
• Capacité
• Itérateurs
• Modificateurs
• Commande ascendante ou descendante
• Opérations
• Algorithmes spécialisés
• Conclusion

Construction / destruction

Une carte est un conteneur associatif qui doit être construit à partir d'une classe de carte.

map (initialiseur_list, const compare & = compare (), const allocator & = allocator ())

L'instruction suivante construit une carte pour la liste ci-dessus par initialisation:

carte MP "BlackBerry", "Dark Blue-Black", "Mango", "Yellow", "Passion Fruit", "Purple", "Plum", "Purple", "Banana" , "jaune";

Notez comment chaque paire a été délimitée.

a = il

La construction d'initialisation suivante, utilise l'opérateur d'affectation:

carte MP = "BlackBerry", "Dark Blue-Black", "Mango", "Yellow", "Passion Fruit", "Purple", "Plum", "Purple", "Banana ", "jaune";

Une carte vide peut être créée avec l'expression de gauche, puis les éléments ajoutés plus tard - voir ci-dessous.

Destruction
Pour détruire une carte, laissez-le sortir de la portée.

CONSTRUCTION ET ADMISSANCE

Pour la carte ci-dessus, une paire se compose d'une clé de chaîne et d'une valeur de chaîne. Un élément de paire peut être construit indépendamment de la carte. Le segment de code suivant crée un objet paire vide à partir d'une classe de paire, puis attribue une clé et une valeur:

Paire PR;
RP.First = "BlackBerry";
RP.deuxième = "bleu foncé";

Le nom de la propriété clé est le premier, et le nom de la propriété de valeur est deuxième. Le code suivant crée une carte vide et insère deux paires à l'aide de la fonction d'insertion de la carte.

map mp;
paire pr0;
PR0.First = "BlackBerry";
PR0.deuxième = "bleu foncé";
Paire PR1;
PR1.premier = "mangue";
PR1.deuxième = "jaune";
député.insert (PR0);
député.insert (PR1);

Affichage du contenu de la carte (impression)

Le code suivant utilise un itérateur (IT), développé à partir du premier élément de la carte, pour afficher les paires de touches / de valeur, à la console:

Map mp = "Plum", "Purple", "mango", "jaune", "Blackberry", "Blue noir", "Passion Fruit", "Purple", " banane "," jaune ";
pour (map :: iterator it = mp.commencer(); il!= MP.fin(); ++ it)
couter BlackBerry => noir bleu foncé
mangue => jaune
Fruit de la passion => violet
prune => violet

=> n'a pas de signification C ++ ici. Il est juste utilisé pour séparer la clé de sa valeur correspondante à l'affichage. Pour obtenir la valeur d'une propriété d'un pointeur (iterator), utilisez -> entre le pointeur (iterator) et le nom de la propriété. Donc, -> a une signification en C++.

Notez que la liste a été affichée dans l'ordre croissant des clés, bien que les éléments n'étaient pas codés.

Les paires de clés / valeur sont toujours accessibles à l'aide du schéma de mise en place pour les éléments. Le segment de code suivant l'illustre:

Map mp = "Plum", "Purple", "mango", "jaune", "Blackberry", "Blue noir", "Passion Fruit", "Purple", " banane "," jaune ";
pour (paire Elem: MP)
couter << elem.first < " << elem.second < yellow
BlackBerry => noir bleu foncé
mangue => jaune
Fruit de la passion => violet
prune => violet

Comme avant. Notez que Elem ici est un nom d'objet et non un pointeur (ni itérateur). Ainsi, il est suivi d'un point et non -> afin d'accéder à la propriété.

Accès à l'élément

T & opérateur [] (key_type && x)

Un élément qui n'est pas dans la carte avant peut être inclus en utilisant sa clé via l'opérateur []. La valeur d'un élément, qui est déjà sur la carte, peut être lu via l'opérateur [] en utilisant sa clé. Le programme suivant illustre ces éléments:

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

map mp;
mp ["plum"] = "violet";
MP ["Passion Fruit"] = "Purple";
MP ["BlackBerry"] = "Dark Blue-Black";
couter<couter<couter<retour 0;

La sortie est:

violet
violet
Black bleu foncé

const t & at (const key_type & x) const

Si la carte est déclarée constante, alors les valeurs des clés ne peuvent pas être modifiées. Cependant, cette fonction membre peut être utilisée pour lire les valeurs des clés. Le code suivant illustre ceci:

const map mp "plum", "violet", "mango", "jaune", "BlackBerry", "Dark Blue-Black";
couter<couter<couter<

La sortie est:

violet
jaune
Black bleu foncé

Capacité

size_type size () const Noexcept

La longueur d'une carte peut être déterminée en utilisant la fonction de membre SIZE (), comme le montre le code suivant:

const map mp "plum", "violet", "mango", "jaune", "BlackBerry", "Dark Blue-Black";
couter<

La sortie est 3.

[[Nodiscard]] bool vide () const noexcept

Cette fonction membre renvoie vrai si la carte est vide, et fausse autrement. Exemple:

const map mp;
couter<

La sortie est 1 pour True. Cela aurait été 0 pour false (sinon).

Itérateurs

iterator begin () noexcept

Cela renvoie un itérateur bidirectionnel pointant vers le premier élément de la carte. La valeur de l'élément (paire) qu'il pointe vers peut être modifiée. Exemple de code:

Map mp "Plum", "Purple", "Mango", "Yellow", "Blackberry", "Dark Blue-Black";
map :: iterator it;
pour (it = mp.commencer(); il!= MP.fin(); it ++)
couter
couterpour (map :: iterator it = mp.commencer(); il!= MP.fin(); it ++)
couter mangue => jaune
prune => violet
BlackBerry => noir bleu foncé
mangue => blanc
prune => violet

La valeur de la deuxième paire de clés / valeur a été modifiée. Notez l'utilisation de l'itérateur final ().

reverse_iterator rbegin () noexcept

Cela renvoie un itérateur inverse bidirectionnel, pointant vers le dernier élément de la carte. La valeur de l'élément auquel il pointe peut être modifiée. Le code suivant produit le même résultat que ce qui précède:

Map mp "Plum", "Purple", "Mango", "Yellow", "Blackberry", "Dark Blue-Black";
map :: reverse_iterator it;
pour (it = mp.rbegin (); il!= MP.déchirer(); it ++)
couter
couterpour (map :: reverse_iterator it = mp =.rbegin (); il!= MP.déchirer(); it ++)
couter mangue => jaune
BlackBerry => noir bleu foncé
prune => violet
mangue => blanc
BlackBerry => noir bleu foncé

La même valeur pour la deuxième paire de touches / valeur a été modifiée.

Modificateurs

Avec la carte, car il sera toujours organisé (ordonné) par les clés, après insérer, peu importe que l'insertion soit ciblée par le programmeur au début, à l'intérieur ou à la fin de la carte. L'ordre croissant par les clés est le résultat par défaut.

La modification de la carte traite de l'insertion, de la mise en œuvre, de l'extraction, de l'effacement et de la compensation. L'insertion et le placage sont similaires, mais le placage est meilleur.

Mettre en œuvre

paire a_uniq.EMPLACE (ARGS)

Cette fonction membre insère les littéraux de la paire de clés / valeur, séparés par la virgule, sans les supports bouclés, comme indiqué dans le code suivant:

map mp = "BlackBerry", "Dark Blue-Black", "Mango", "Yellow", "Passion Fruit", "Purple";
paire PR = MP.emplace ("banane", "jaune");
pour (Auto Elem: MP)
couter << elem.first < " << elem.second << endl;
couter<couter BlackBerry => noir bleu foncé
mangue => jaune
Fruit de la passion => violet
banane => 1

La fonction membre EMPlace (Args) renvoie une paire correspondant à l'élément inséré. La clé de cette paire de retour est un itérateur pointant vers l'élément inséré. La valeur de cette paire de retour est vraie (1) si l'insertion a eu lieu et fausse (0) si l'insertion n'a pas eu lieu.

Notez la façon dont le type de retour pour l'emplacement (args) a été codé. De plus, la paire de retour n'a pas été utilisée pour obtenir la clé / valeur de la paire de cartes insérée dans la dernière instruction de sortie. Il y a deux types de paires ici: la paire pour la carte et la paire de retour. Ils ne sont pas compatibles. Si la clé existait déjà dans la carte, l'itérateur retourné pointerait vers la clé qui existait; Ensuite, la valeur booléenne serait fausse.

Insertion

paire insérer (value_type && x)

Cette fonction membre insère les littéraux de la paire de clés / valeur, séparés par la virgule, avec les supports bouclés, comme indiqué dans le code suivant:

map mp = "BlackBerry", "Dark Blue-Black", "Mango", "Yellow", "Passion Fruit", "Purple";
paire PR = MP.insert ("banane", "jaune");
pour (Auto Elem: MP)
couter << elem.first < " << elem.second << endl;
couter<couter BlackBerry => noir bleu foncé
mangue => jaune
Fruit de la passion => violet
banane => 1

L'explication est similaire au cas ci-dessus pour l'emplacement (args).

paire INSERT (const value_type & x)

L'identifiant d'une paire peut être utilisé comme argument de la fonction insert (). Illustration:

map mp = "BlackBerry", "Dark Blue-Black", "Mango", "Yellow", "Passion Fruit", "Purple";
Paire PR;
RP.premier = "banane";
RP.deuxième = "jaune";
paire IB = MP.insérer (pr);
pour (Auto Elem: MP)
couter << elem.first < " << elem.second << endl;
couter<couter BlackBerry => noir bleu foncé
mangue => jaune
Fruit de la passion => violet
banane => 1

L'explication est similaire au cas ci-dessus.

INSERT VOID (initializer_list)

Une liste entière peut être insérée. Immédiatement après l'insertion, il y a un réarrangement (par ordre croissant). Illustration:

map mp = "BlackBerry", "Dark Blue-Black", "Mango", "Yellow", "Passion Fruit", "Purple";
député.insert ("pastèque", "vert", "raisin", "rose", "abricot", "orange");
pour (Auto Elem: MP)
couter << elem.first < " << elem.second < orange
BlackBerry => noir bleu foncé
raisin => rose
mangue => jaune
Fruit de la passion => violet
pastèque => vert

Remarque: aucune clé de la liste ne doit déjà exister sur la carte.

INSERT VOID (Inputiterator First, Inputiterator en dernier)

Une gamme, [i, j) d'une autre carte peut être insérée. Ici, moi et j sommes des itérateurs. Illustration:

Map MP1 = "Grape", "Pink", "Apricot", "Orange", "Strawberry", "Red", "Peach", "Dark Yellow", "Papaya", "orange";
map :: iterator itb = mp1.commencer();
itb ++;
map :: iterator ite = mp1.fin();
ite--; ite--;
map mp2 = "BlackBerry", "Dark Blue-Black", "mango", "jaune", "Passion Fruit", "Purple";
mp2.insérer (itb, ite);
pour (Auto Elem: MP2)
couter << elem.first < " << elem.second < dark blue-black
raisin => rose
mangue => jaune
Papaya => Orange
Fruit de la passion => violet

Notez que l'élément correspondant à J de la première carte n'a pas été inséré. Ceci est conforme à la notation, [i, j).

Effacement

size_type efface (const key_type & x)

Efface l'élément identifié par clé et renvoie le nombre d'éléments effacés (devrait être 1 dans le cas de non-multimap). Illustration:

map mp = "BlackBerry", "Dark Blue-Black", "Mango", "Yellow", "Passion Fruit", "Purple";
int n = MP.Effacer ("mangue");
couter<pour (Auto Elem: MP)
couter << elem.first < " << elem.second << endl;
couter <couter<Fruit de la passion => violet
2

L'élément effacé est supprimé, en ce qui concerne l'utilisateur. Le nombre d'éléments est donc réduit.

Iterator Erase (const_iterator position)

L'effacement peut être fait en utilisant un itérateur. Renvoie un itérateur pointant vers l'élément après celui qui est effacé. Illustration:

map mp = "BlackBerry", "Dark Blue-Black", "Mango", "Yellow", "Passion Fruit", "Purple";
map :: iterator it = mp.commencer();
it ++;
map :: iterator iter = MP.efface le);
couter pour (Auto Elem: MP)
couter << elem.first < " << elem.second << endl;
couter <couter<BlackBerry => noir bleu foncé
Fruit de la passion => violet
2

Iterator effacer (const_iterator d'abord, const_iterator dernier)

Cela utilise des itérateurs pour effacer une plage de la carte commandée. Il renvoie un itérateur pointant vers l'élément après la plage effacée. Illustration:

Map mp = "Grape", "Pink", "Apricot", "Orange", "Strawberry", "Red", "Peach", "Dark Yellow", "Papaya", "orange";
pour (Auto Elem: MP)
couter << elem.first < " << elem.second << endl;
couter <map :: iterator itb = mp =.commencer();
itb ++;
map :: iterator ite = mp.fin();
ite--; ite--;
map :: iterator iter = MP.effacer (itb, ite);
couter pour (Auto Elem: MP)
couter << elem.first < " << elem.second << endl;
couter <couter<raisin => rose
Papaya => Orange
pêche => jaune foncé
Strawberry => rouge
pêche => jaune foncé
abricot => orange
pêche => jaune foncé
Strawberry => rouge
3

La commande du contenu d'origine de la carte est d'abord affichée à la sortie afin que la plage effacée puisse être appréciée. Notez que l'élément pointé par le deuxième argument Itérateur n'est pas effacé.

Clair

void clear () noexcept

Efface tous les éléments de la carte, faisant la taille de la carte, zéro. Exemple:

Map mp = "Grape", "Pink", "Apricot", "Orange", "Strawberry", "Red";
député.clair();
couter<

La sortie est 0.

Extraction
Cela traite avec node_type - voir plus tard.

Fusion
Lorsque deux cartes sont fusionnées, les éléments se mélangent dans l'ordre (ascendant); Aucune paire de clés / valeur n'est séparée.

vide a.fusionner (A2)

Un élément de A2 avec la même clé dans A n'est pas extrait. Cela traite avec node_type - voir plus tard.

Commande ascendante ou descendante

Par défaut, une carte devient ascendante par des clés juste après la création. Il peut être fait descendant. Dans les supports d'angle de modèle, le troisième paramètre a le type par défaut, moins. Et donc, il n'a pas à être dactylographié. Afin de rendre la carte descendant par clé, plus grande doit être utilisée, comme dans le code suivant:

carte MP = "Grape", "Pink", "Apricot", "Orange", "Strawberry", "Red";
pour (Auto Elem: MP)
couter << elem.first < " << elem.second < red
raisin => rose
abricot => orange

Dès qu'une carte est créée, il est ordonné de monter ou de descendre (ascendant par défaut). moins ou plus est connu comme un objet compare.

Opérations

Iterator Find (const key_type & x)

Renvoie l'itérateur de l'élément dont la clé est l'argument à trouver (). Illustration:

carte MP = "Grape", "Pink", "Apricot", "Orange", "Strawberry", "Red";
map :: iterator it = mp.trouver ("raisin");
couter

Iterator Lower_Bound (const key_type & x)

Dans une carte, les éléments sont organisés par clé, par ordre croissant, par défaut. Si le programmeur veut connaître l'itérateur qui pointe vers l'élément qui n'est pas inférieur à celui d'une clé particulière, il doit utiliser cette fonction membre. Illustration:

Map mp = "Grape", "Pink", "Apricot", "Orange", "Strawberry", "Red", "Peach", "Dark Yellow", "Papaya", "orange";
pour (Auto Elem: MP)
couter << elem.first < " << elem.second << endl;
couter <map :: iterator it = mp.Lower_Bound ("Papaya");
couter raisin => rose
Papaya => Orange
pêche => jaune foncé
Strawberry => rouge
Papaya => Orange

Dans cette situation, l'itérateur pointe vers l'élément clé. Si la clé n'est pas trouvée, la fonction renverra un itérateur qui pointe juste après la fin de la carte. Dans cette situation, c'est cyclique, et ce serait le premier élément de la carte.

iterator upper_bound (const key_type & x)

Si le programmeur veut connaître l'itérateur qui pointe l'élément avec une clé supérieure à K, il doit utiliser cette fonction membre. Illustration:

Map mp = "Grape", "Pink", "Apricot", "Orange", "Strawberry", "Red", "Peach", "Dark Yellow", "Papaya", "orange";
pour (Auto Elem: MP)
couter << elem.first < " << elem.second << endl;
couter <map :: iterator it = mp.Upper_Bound ("Papaya");
couter raisin => rose
Papaya => Orange
pêche => jaune foncé
Strawberry => rouge
pêche => jaune foncé

Un itérateur pointant vers l'élément juste après le retour de l'élément de clé. Si la clé est pour le dernier élément, une exception doit être jetée. Si la clé n'existe pas, le résultat n'est pas fiable.

Algorithmes spécialisés

Ce qui suit est la syntaxe d'une fonction d'algorithme spécialisé:

modèle
VOID Swap (Map & X, Map & Y) Noexcept (NoExcept (x.swap (y)));

La syntaxe suivante peut être utilisée à la place:

Échange void (carte et)

Cela échange les paires des deux cartes, qui n'ont pas besoin d'être de la même taille. Exemple:

Map MP1 = "Plum", "Purple", "Mango", "Yellow", "Blackberry", "Dark Blue-Black", "Passion Fruit", "Purple", " banane "," jaune ";
map mp2 = "pastèque", "vert", "Grape", "Pink", "abricot", "orange", "Strawberry", "Red", "Peach", " Jaune foncé ", " Papaya "," Orange ";
MP1.échange (MP2);
couter << "New mp1:" << endl;
pour (Auto Elem: MP1)
couter << elem.first < " << elem.second << endl;
couter<couter << "New mp2:" << endl;
pour (Auto Elem: MP2)
couter << elem.first < " << elem.second << endl;

Conclusion

Une carte se compose de paires de clés / valeur. Il est commandé par des clés, soit ascendant ou descendant. L'ordre par défaut monte. Fonctions des membres de base pour la carte: map (), opérateur [], at (), size (), vide (), begin (), end (), rbegin (), rend (), emplace (), insert () , Erase (), Clear (), Find (), Lower_Bound (), Upper_Bound () et A1SWAP (A2).