Carte dans la bibliothèque de modèles standard C++ (STL) avec exemple d'impression

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 servent à 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
Insérer des données dans std::map
Rechercher dans une carte
Supprimer des données d'une carte

Pourquoi utiliser std::map ?

Voici les raisons d'utiliser la carte :

std : :la carte stocke les clés uniques uniquement dans un ordre trié en fonction des critères de tri choisis.
Il est facile et plus 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 tableau associatif.
std::map est implémentable à l'aide d'arbres binaires (équilibrés).

Syntaxe :

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

std::map<key_datatype, value_datatype>map_name;

Le key_datatype indique le type de données des clés de carte.
Le value_datatype indique le type de données des valeurs correspondant aux clés de carte.
map_name est le nom de la carte.

Par exemple :

map<string, int> my_map;

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

Types de membres :

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

type_clé : Clé (Le premier paramètre du modèle)
mapped_type : T (Le deuxième paramètre du modèle)
key_compare : Comparer (le troisième paramètre du modèle)
type_allocateur : Alloc (le quatrième paramètre du modèle)
type_valeur : paire
value_compare : Classe de fonctions imbriquées pour comparer des éléments
référence : type_allocateur ::référence
const_reference : allocator_type::const_reference
pointeur : type_allocateur ::pointeur
const_pointer : type_allocateur ::const_pointer
itérateur : un itérateur bidirectionnel vers le value_type
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
différence_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 :

commence()- Cette fonction renvoie l'itérateur au 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 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.
effacer(const g) – Cette fonction supprime la valeur-clé g d'une carte.
Effacer ()- Cette fonction supprime tous les éléments d'une carte.

Itérer 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 <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 :

Explication du code :

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

Insérer des données dans std::map

Vous pouvez saisir des éléments dans std::map à l'aide de 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. S'il est présent, l'entrée ne sera pas insérée, mais elle renvoie l'itérateur pour l'entrée existante. S'il n'est pas présent, l'entrée est insérée.

La fonction a 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.

Le 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 <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 :

Explication du code :

Incluez le fichier d'en-tête de carte dans notre code pour utiliser ses fonctions.
Inclure le fichier d'en-tête iostream dans notre code pour utiliser ses fonctions.
Incluez l'espace de noms std dans notre code pour utiliser ses classes sans l'appeler.
Appelez la fonction main(). Le { marque le début du corps de la fonction.
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.
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.
Essayer de faire une entrée dans une clé déjà existante. Comme la clé 1 existe déjà dans la carte, la saisie ne sera pas effectuée.
Utiliser la fonction insert_or_assign() pour insérer ou modifier une entrée existante. Puisque la clé 1 existe déjà, sa valeur sera changée en 6.
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.
Utilisez une boucle for pour créer un itérateur nommé itr pour parcourir les éléments de la carte nommée m.
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.
Fin du corps de la boucle for a.
Le programme doit renvoyer une valeur en cas de réussite.
Fin du corps de la fonction main().

Rechercher 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 retourné.

Exemple 2 :

#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 :

Explication du code :

Incluez le fichier d'en-tête iostream dans notre code pour utiliser ses fonctions sans générer d'erreurs.
Incluez le fichier d'en-tête de chaîne dans notre code pour utiliser ses fonctions sans générer d'erreurs.
Incluez le fichier d'en-tête de la carte dans notre code pour utiliser ses fonctions sans générer d'erreurs.
Incluez l'espace de noms std dans notre code pour utiliser ses classes sans l'appeler.
Appelez la fonction main(). Le { marque le début du corps de la fonction main().
Créez une carte nommée Students dont les clés seront des nombres entiers et des chaînes de valeurs.
Insérez des valeurs dans la carte Élèves. Une clé de 200 et une valeur d'Alice seront insérées dans la carte.
Insérez des valeurs dans la carte Élèves. Une clé de 201 et une valeur de John seront insérées dans la carte.
Recherchez la valeur associée à une clé de 201.
Utilisez une instruction if pour vérifier si la valeur de la clé est trouvée.
Imprimez la valeur de la clé à côté d'un texte sur la console.
Fin du corps de l'instruction if.
Fin du corps de la fonction main().

Supprimer des 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 <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 :

Explication du code :

Inclure le fichier d'en-tête iostream dans notre code pour utiliser ses fonctions.
Incluez le fichier d'en-tête de chaîne dans notre code pour utiliser ses fonctions.
Incluez le fichier d'en-tête de carte dans notre code pour utiliser ses fonctions.
Incluez l'espace de noms std dans notre code pour utiliser ses classes sans l'appeler.
Appelez la fonction main(). Le { marque le début du corps de la fonction main().
Créez une carte nommée my_map dont les clés seront des chaînes et des valeurs entières.
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.
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.
Ajoutez une valeur 3 dans la carte my_map avec une clé de lion.
Créez un itérateur pour parcourir la carte my_map à la recherche du chat clé.
Supprimez l'élément pointé par l'itérateur.
Utilisez un itérateur pour parcourir les éléments de la carte my_map du début à la fin.
Imprimez le contenu de la carte my_map sur la console.
Le programme doit renvoyer une sortie une fois terminé avec succès.
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 clé et une valeur mappée.
Dans une carte, deux valeurs mappées ne peuvent pas partager des valeurs clés.
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 itérer sur 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.

Vecteur dans la bibliothèque de modèles standard C++ (STL) avec exemple Classe et objet C++ avec exemple

Langue C