Carte en C++ Bibliothèque de modèles standard (STL)

Qu'est-ce que la carte dans C++?

In C++Une MAP est un conteneur associatif stockant des éléments sous forme de correspondance. Chaque élément de la MAP est composé d'une clé et d'une valeur associée. Deux valeurs associées ne peuvent pas partager la même clé.

Les valeurs clés permettent de trier et d'identifier les éléments de manière unique, tandis que les valeurs associées stockent le contenu lié à chaque clé. Ces deux types peuvent différer, mais le type membre les combine en une paire qui les contient toutes deux.

Avant d'écrire la moindre ligne de code, il est utile de comprendre pourquoi une carte est souvent le conteneur idéal à utiliser.

Pourquoi utiliser std :: map ?

Voici les raisons d'utiliser une carte :

• std::map ne stocke que des clés uniques, triées selon les critères de tri choisis.
• La recherche d'éléments à l'aide de la clé est simple et rapide.
• Un seul élément est attaché à chaque clé.
• std::map peut être utilisé comme tableau associatif.
• std::map est implémentable à l'aide d'arbres binaires équilibrés.

Pour profiter de ces avantages, commencez par la syntaxe de déclaration.

Syntaxe

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

std::map<key_datatype, value_datatype>map_name; 

• Le type_de_données_clé désigne le type de données des clés de carte.
• Le type de données de valeur désigne le type de données des valeurs correspondant aux clés de la carte.
• Le nom_carte est le nom de la carte.

Par exemple :

map<string, int> my_map; 

Nous avons déclaré une carte nommée my_map. Cette carte aura une chaîne de caractères comme type de clé et un entier comme type de valeur.

Types de membres

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

• type de clé: Clé (le premier paramètre du modèle)
• type_mappé : T (le deuxième paramètre du modèle)
• clé_compare : Comparer (le troisième paramètre du modèle)
• type_allocateur : Alloc (le quatrième paramètre du modèle)
• type de valeur: paire
• valeur_compare : Classe de fonctions imbriquée pour comparer des éléments
• référence: allocator_type :: référence
• const_référence : allocator_type :: const_reference
• aiguille: allocator_type :: pointeur
• const_pointeur : allocator_type :: const_pointer
• itérateur : un itérateur bidirectionnel vers le value_type
• const_iterator : un itérateur bidirectionnel vers le const value_type
• inverse_iterator : un itérateur inverse
• const_reverse_iterator : un itérateur inverse constant
• type_différence : ptrdiff_t
• type de taille: taille_t

Fonctions intégrées de std :: map

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

• commencer () – Cette fonction renvoie l'itérateur vers le premier élément de la carte.
• Taille() – Cette fonction renvoie le nombre d'éléments dans une carte.
• vide() – Cette fonction renvoie une valeur booléenne indiquant si une carte est vide.
• insérer(paire(clé, valeur)) – Cette fonction insère une nouvelle paire clé-valeur dans une carte.
• trouver(val) – Cette fonction renvoie l'itérateur vers l'élément val si celui-ci est trouvé. Sinon, elle retourne m.end().
• effacer(position de l'itérateur) – Cette fonction supprime l'élément à la position pointée par l'itérateur.
• effacer (const g) – Cette fonction supprime la paire clé-valeur g d'une carte.
• clair() – Cette fonction supprime tous les éléments d'une carte.

Une fois les fonctions définies, les exemples suivants les mettent en pratique, en commençant par l'itération.

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

Vous pouvez parcourir les éléments de la carte. Il suffit de créer un itérateur et de l'utiliser à cet effet. Par exemple :

Exemple 1

#include <iostream>
#include <string>
#include <map> 

using namespace std;
int main() {

	map<int, string> Students;

	Students.insert(std::pair<int, string>(200, "Alice"));

	Students.insert(std::pair<int, string>(201, "John"));

	cout << "Map size is: " << Students.size() << endl;

	cout << endl << "Default map Order is: " << endl;

	for (map<int, string>::iterator it = Students.begin(); it != Students.end(); ++it) {

		cout << (*it).first << ": " << (*it).second << endl;
	}
}

Sortie :

Voici une capture d'écran du code :

Code Explication:

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 Étudiants où les clés seront des entiers et les valeurs seront des chaînes.
7. Insérez des valeurs dans la carte Étudiants. Une clé de 200 et une valeur d'Alice seront insérées dans la carte.
8. Insérez des valeurs dans la carte Étudiants. 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 Students. Elle devrait renvoyer 2.
10. Imprimez du texte sur la console.
11. Utilisez une boucle for pour créer un itérateur nommé pour parcourir les éléments de la carte nommés Students.
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 insérer des éléments dans std::map à l'aide de la fonction insert(). N'oubliez pas que les clés de std::map doivent être uniques.

La fonction vérifie d'abord si chaque clé est présente dans la table de correspondance. Si c'est le cas, l'entrée n'est pas insérée, mais elle renvoie l'itérateur de l'entrée existante. Sinon, l'entrée est insérée.

La fonction présente les variantes suivantes :

• insérer(paire) – avec cette variante, une paire clé-valeur est insérée dans la carte.
• insérer(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_assign() 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 <map>
#include <iostream>

using namespace std;

int main() {

	map<int, int> 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;
}

Sortie :

Voici une capture d'écran du code :

Code Explication:

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 sur la carte.
6. Insérez 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. La clé 1 étant déjà présente dans la carte, la saisie ne sera pas effectuée.
8. Utilisez la fonction `insert_or_assign()` pour insérer ou modifier une entrée existante. La clé 1 existant déjà, sa valeur sera modifiée et deviendra 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 vers la ligne suivante.
10. Utiliser un pour la boucle pour créer un itérateur nommé itr pour parcourir les éléments de la carte nommés 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 vers 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 sur une carte

La fonction `find()` permet de rechercher des éléments dans une map à partir de leurs clés. Si la clé est introuvable, la fonction renvoie `std::map::end`. Sinon, elle renvoie un itérateur contenant l'élément recherché.

Exemple 3

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

Sortie :

Voici une capture d'écran du code :

Code Explication:

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(). L'accolade ouvrante { marque le début du corps de la fonction main().
6. Créez une carte nommée Students dont les clés seront des entiers et des chaînes de valeurs.
7. Insérez des valeurs dans la carte Étudiants. Une clé de 200 et une valeur d'Alice seront insérées dans la carte.
8. Insérez des valeurs dans la carte Étudiants. 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é à côté 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

On peut utiliser la fonction erase() pour supprimer une valeur d'une map. Il suffit de créer un itérateur pointant vers l'élément à supprimer, puis de le passer à la fonction erase().

Exemple 4

#include <iostream>
#include <string>
#include <map>

using namespace std;
int main() {

	map<std::string, int> my_map;

	my_map.insert(std::make_pair("cow", 1));

	my_map.insert(std::make_pair("cat", 2));

	my_map["lion"] = 3;

	map<std::string, int>::iterator it = my_map.find("cat");

	my_map.erase(it);

	for (map<string, int>::iterator it = my_map.begin(); it != my_map.end(); ++it)

		cout << (*it).first << ": " << (*it).second << endl;

  return 0;
}

Sortie :

Voici une capture d'écran du code :

Code Explication:

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(). L'accolade ouvrante { 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 map my_map avec une clé de lion.
10. Créez un itérateur pour parcourir la carte my_map à la recherche de la clé cat.
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 une sortie une fois terminé.
15. Fin du corps de la fonction main().

FAQ