Mapper dans la bibliothèque de modèles standard C ++ (STL) avec exemple

Table des matières:

Anonim

Qu'est-ce que std :: map?

En C ++, une MAP est un conteneur associatif stockant des éléments sous une forme mappée. Chaque élément de la carte est composé d'une valeur-clé et d'une valeur mappée. Deux valeurs mappées ne peuvent pas partager les mêmes valeurs de clé.

Les valeurs clés sont bonnes pour trier et identifier les éléments de manière unique. Les valeurs mappées sont destinées à stocker le contenu associé à la clé. Les deux types peuvent différer, mais le type de membre les combine via un type de paire qui combine les deux.

Dans ce didacticiel C ++, vous apprendrez:

  • Qu'est-ce que std :: map?
  • Pourquoi utiliser std :: map?
  • Syntaxe:
  • Types de membres:
  • Fonctions intégrées
  • Itération sur les éléments de la carte
  • Insertion de données dans std :: map:
  • Recherche dans une carte
  • Suppression de données d'une carte

Pourquoi utiliser std :: map?

Voici les raisons d'utiliser la carte:

  • std :: map stocke les clés uniques uniquement dans l'ordre trié en fonction des critères de tri choisis.
  • Il est facile et rapide de rechercher des éléments à l'aide de la clé.
  • Un seul élément est attaché à chaque clé.
  • std :: map peut être utilisé comme un tableau associatif.
  • std :: map est implémentable en utilisant des arbres binaires (équilibrés).

Syntaxe:

Pour déclarer std :: map, utilisez cette syntaxe:

std::mapmap_name;
  • Le key_datatype désigne le type de données des clés de mappage.
  • Le value_datatype désigne le type de données des valeurs correspondant aux clés de la carte.
  • Le nom de la carte est le nom de la carte.

Par exemple:

map my_map;

Nous avons déclaré une carte nommée my_map. La carte aura une chaîne comme types de données clés et un entier comme type de données valeurs .

Types de membres:

Les fonctions membres peuvent utiliser les types de membres suivants comme paramètres ou comme type de retour:

  • key_type: Key (Le premier paramètre du modèle)
  • mapped_type: T (Le deuxième paramètre du modèle)
  • key_compare: Compare (Le troisième paramètre du modèle)
  • allocator_type: Alloc (le quatrième paramètre du modèle)
  • value_type: paire
  • value_compare: classe de fonctions imbriquées pour comparer des éléments
  • reference: allocator_type :: reference
  • const_reference: allocator_type :: const_reference
  • pointeur: allocator_type :: pointer
  • const_pointer: allocator_type :: const_pointer
  • itérateur: un itérateur bidirectionnel vers le type_valeur
  • const_iterator: un itérateur bidirectionnel vers le const value_type
  • reverse_iterator: un itérateur inverse
  • const_reverse_iterator: un itérateur inverse constant
  • difference_type: ptrdiff_t
  • size_type: size_t

Fonctions intégrées

std :: map est livré avec des fonctions intégrées. Certains d'entre eux incluent:

  • begin () - Cette fonction renvoie l'itérateur vers le premier élément de la carte.
  • size () - Cette fonction renvoie le nombre d'éléments dans une carte.
  • empty () - Cette fonction renvoie une valeur booléenne indiquant si une carte est vide.
  • insert (pair (key, value)) - Cette fonction insère une nouvelle paire clé-valeur dans une carte.
  • find (val) - Cette fonction donne l'itérateur à l'élément val s'il est trouvé. Sinon, il renverra m.end ().
  • Effacer (position de l'itérateur) - Cette fonction supprime l'élément à la position pointée par l'itérateur.
  • erase (const g) - Cette fonction supprime la valeur-clé g d'une carte.
  • Effacer () - Cette fonction supprime tous les éléments d'une carte.

Itération sur les éléments de la carte

Vous pouvez parcourir les éléments de la carte. Nous devons simplement créer un itérateur et l'utiliser pour cela. Par exemple:

Exemple 1:

#include #include #include using namespace std;int main() {map Students;Students.insert(std::pair(200, "Alice"));Students.insert(std::pair(201, "John"));cout << "Map size is: " << Students.size() << endl;cout << endl << "Default map Order is: " << endl;for (map::iterator it = Students.begin(); it != Students.end(); ++it) {cout << (*it).first << ": " << (*it).second << endl;}}

Production:

Voici une capture d'écran du code:

Explication du code:

  1. Incluez le fichier d'en-tête iostream dans notre code pour utiliser ses fonctions.
  2. Incluez le fichier d'en-tête de chaîne dans notre code pour utiliser ses fonctions.
  3. Incluez le fichier d'en-tête de la carte dans notre code pour utiliser ses fonctions.
  4. Incluez l'espace de noms std dans notre code pour utiliser ses classes sans l'appeler.
  5. Appelez la fonction main (). Le {marque le début du corps de la fonction.
  6. Créez une carte nommée Etudiants où les clés seront des entiers et les valeurs seront des chaînes.
  7. Insérez des valeurs dans la carte Etudiants. Une clé de 200 et une valeur d'Alice seront insérées dans la carte.
  8. Insérez des valeurs dans la carte Etudiants. Une clé de 201 et une valeur de John seront insérées dans la carte.
  9. Utilisez la fonction size () pour obtenir la taille de la carte nommée Etudiants. Cela devrait renvoyer un 2.
  10. Imprimez du texte sur la console.
  11. Utilisez une boucle for pour créer un itérateur nommé pour itérer sur les éléments de la carte nommés étudiants.
  12. Imprimez les valeurs de la carte Etudiants sur la console.
  13. Fin du corps de la boucle for.
  14. Fin du corps de la fonction main ().

Insertion de données dans std :: map

Vous pouvez entrer des éléments dans std :: map en utilisant la fonction insert (). N'oubliez pas que les clés std :: map doivent être uniques.

Ainsi, il vérifie d'abord si chaque clé est présente dans la carte. Si elle est présente, l'entrée ne sera pas insérée, mais elle renvoie l'itérateur de l'entrée existante. S'il n'est pas présent, l'entrée est insérée.

La fonction a les variations suivantes:

  • insert (pair) - avec cette variante, une paire clé-valeur est insérée dans la carte.
  • insert (start_itr, end_itr) - avec cette variante, les entrées seront insérées dans la plage définie par start_itr et end_itr à partir d'une autre carte.

La fonction insert_or_assing () fonctionne de la même manière que la fonction insert (), mais si la clé donnée existe déjà dans la carte, sa valeur sera modifiée.

Exemple 2:

#include #include using namespace std;int main() {map m{ {1,3} , {2,4} , {3,5} };m.insert({ 5, 6 });m.insert({ 1, 8 });m.insert_or_assign(1, 6);cout << "Key\tElement\n";for (auto itr = m.begin(); itr != m.end(); ++itr) {cout << itr->first << '\t' << itr->second << '\n';}return 0;}

Production:

Voici une capture d'écran du code:

Explication du code:

  1. Incluez le fichier d'en-tête de la carte dans notre code pour utiliser ses fonctions.
  2. Incluez le fichier d'en-tête iostream dans notre code pour utiliser ses fonctions.
  3. Incluez l'espace de noms std dans notre code pour utiliser ses classes sans l'appeler.
  4. Appelez la fonction main (). Le {marque le début du corps de la fonction.
  5. Créez une carte nommée m où les clés seront des entiers et les valeurs seront des entiers. Trois entrées ont été faites dans la carte.
  6. Insérer une nouvelle entrée dans la carte m. Une clé de 5 et une valeur de 6 seront insérées dans la carte.
  7. Essayer de faire une entrée dans une clé déjà existante. Puisque la clé 1 existe déjà dans la carte, l'entrée ne sera pas effectuée.
  8. Utilisation de la fonction insert_or_assign () pour insérer ou modifier une entrée existante. Étant donné que la clé 1 existe déjà, sa valeur passera à 6.
  9. Imprimez du texte sur la console. Le caractère "\ t" crée un espace horizontal tandis que le caractère "\ n" déplace le curseur de la souris sur la ligne suivante.
  10. Utilisez une boucle for pour créer un itérateur nommé itr pour parcourir les éléments de la carte nommée m.
  11. Imprimez les valeurs de la carte m sur la console. Le caractère "\ t" crée un espace horizontal entre chaque clé et sa valeur correspondante. En revanche, le caractère "\ n" déplace le curseur de la souris sur la ligne suivante après chaque itération.
  12. Fin du corps de la boucle for.
  13. Le programme doit renvoyer une valeur une fois terminé.
  14. Fin du corps de la fonction main ().

Recherche dans une carte

Nous pouvons utiliser la fonction find () pour rechercher des éléments dans une carte par leurs clés. Si la clé n'est pas trouvée, la fonction renvoie std :: map :: end. Sinon, un itérateur de l'élément recherché sera renvoyé.

Exemple 2:

#include #include #include using namespace std;int main() {map Students;Students.insert(std::pair(200, "Alice"));Students.insert(std::pair(201, "John"));std::map::iterator it = Students.find(201);if (it != Students.end()) {std::cout << endl << "Key 201 has the value: => "<< Students.find(201)->second << '\n';}}

Production:

Voici une capture d'écran du code:

Explication du code:

  1. Incluez le fichier d'en-tête iostream dans notre code pour utiliser ses fonctions sans obtenir d'erreurs.
  2. Incluez le fichier d'en-tête de chaîne dans notre code pour utiliser ses fonctions sans obtenir d'erreurs.
  3. Incluez le fichier d'en-tête de la carte dans notre code pour utiliser ses fonctions sans obtenir d'erreurs.
  4. Incluez l'espace de noms std dans notre code pour utiliser ses classes sans l'appeler.
  5. Appelez la fonction main (). Le {marque le début du corps de la fonction main ().
  6. Créez une carte nommée Etudiants dont les clés seront des entiers et des chaînes de valeurs.
  7. Insérez des valeurs dans la carte Etudiants. Une clé de 200 et une valeur d'Alice seront insérées dans la carte.
  8. Insérez des valeurs dans la carte Etudiants. Une clé de 201 et une valeur de John seront insérées dans la carte.
  9. Recherchez la valeur associée à une clé de 201.
  10. Utilisez une instruction if pour vérifier si la valeur de la clé est trouvée.
  11. Imprimez la valeur de la clé avec du texte sur la console.
  12. Fin du corps de l'instruction if.
  13. Fin du corps de la fonction main ().

Suppression de données d'une carte

Nous pouvons utiliser la fonction erase () pour supprimer une valeur d'une carte. Nous créons simplement un itérateur qui pointe vers l'élément à supprimer. L'itérateur est ensuite passé à la fonction erase ().

Exemple 3:

#include #include #include using namespace std;int main() {map my_map;my_map.insert(std::make_pair("cow", 1));my_map.insert(std::make_pair("cat", 2));my_map["lion"] = 3;map::iterator it = my_map.find("cat");my_map.erase(it);for (map::iterator it = my_map.begin(); it != my_map.end(); ++it)cout << (*it).first << ": " << (*it).second << endl;return 0;}

Production:

Voici une capture d'écran du code:

Explication du code:

  1. Incluez le fichier d'en-tête iostream dans notre code pour utiliser ses fonctions.
  2. Incluez le fichier d'en-tête de chaîne dans notre code pour utiliser ses fonctions.
  3. Incluez le fichier d'en-tête de la carte dans notre code pour utiliser ses fonctions.
  4. Incluez l'espace de noms std dans notre code pour utiliser ses classes sans l'appeler.
  5. Appelez la fonction main (). Le {marque le début du corps de la fonction main ().
  6. Créez une carte nommée my_map dont les clés seront des chaînes et des valeurs entières.
  7. Insérez des valeurs dans la carte my_map. Une clé de vache et une valeur de 1 seront insérées dans la carte.
  8. Insérez des valeurs dans la carte my_map. Une clé de Cat et une valeur de 2 seront insérées dans la carte.
  9. Ajoutez une valeur 3 dans la carte my_map avec une clé de lion.
  10. Créez un itérateur pour parcourir la carte my_map à la recherche du chat clé.
  11. Supprimez l'élément pointé par l'itérateur.
  12. Utilisez un itérateur pour parcourir les éléments de la carte my_map du début à la fin.
  13. Imprimez le contenu de la carte my_map sur la console.
  14. Le programme doit renvoyer la sortie une fois terminé.
  15. Fin du corps de la fonction main ().

Résumé:

  • Une carte est un conteneur associatif qui stocke des éléments sous une forme mappée.
  • Chaque élément de la carte a une valeur de clé et une valeur mappée.
  • Dans une carte, deux valeurs mappées ne peuvent pas partager de valeurs de clé.
  • Les valeurs clés aident à trier et à identifier les éléments de manière unique.
  • Les valeurs mappées aident à stocker le contenu associé à la clé.
  • La carte C ++ stocke les clés uniques dans un ordre trié.
  • Pour travailler avec la carte C ++, nous créons un itérateur pour parcourir les éléments.
  • Avec l'itérateur, nous pouvons effectuer des tâches telles que la recherche et la suppression d'éléments de la carte.