Parmi les nombreuses opérations disponibles pour « std::map », la fonction « effacer » s'impose comme un outil crucial pour supprimer les éléments en fonction de leurs clés. Un « std :: map » est un conteneur associatif organisé qui comprend des paires clé-valeur. La disposition des éléments dans un « std :: map » est systématiquement triée en fonction de leurs clés, facilitant les opérations efficaces telles que la recherche, l'insertion et la suppression en fonction des valeurs clés.
Dans le domaine du C++, la fonction « std::map::erase » sert de fonction membre de la classe « std::map », permettant l'élimination d'éléments spécifiques de la carte. Il se présente sous diverses formes, offrant une flexibilité dans la spécification des éléments à effacer. Dans cet article, nous approfondirons les détails de « std::map::erase », en fournissant plusieurs exemples pour illustrer sa polyvalence.
Exemple 1 : Effacement par clé
La possibilité d'effacer les éléments par clé dans le « std :: map » est une fonctionnalité fondamentale fournie par la bibliothèque de modèles standard C++. Cette opération est couramment utilisée lorsque vous devez gérer et manipuler les paires clé-valeur dans un programme, et elle constitue un moyen pratique de supprimer des éléments spécifiques en fonction de leurs clés. Nous allons créer un exemple pour montrer comment utiliser le « std :: map » pour créer une carte, effacer un élément par clé, puis afficher la carte modifiée.
#include
#include
int main ( ) {
std :: carte < int, std :: chaîne > maCarte ;
maCarte [ 1 ] = 'Rouge' ;
maCarte [ 2 ] = 'Bleu' ;
maCarte [ 3 ] = 'Vert' ;
maCarte.effacer ( 2 ) ;
pour ( constante automatique & paire : maCarte ) {
std :: cout << paire.premier << ' : ' << paire.seconde << std::endl;
}
retour 0 ;
}
Dans cet exemple, nous commençons par inclure les bibliothèques standard C++ nécessaires telles que
Pour présenter l'état résultant de la carte, nous utilisons une boucle « pour » qui parcourt chaque paire clé-valeur dans « myMap ». Nous utilisons l'objet « std :: cout » à l'intérieur de la boucle pour imprimer chaque paire clé-valeur sur la console. Enfin, l'instruction « return 0 » conclut la fonction « main » qui signale la réussite de l'exécution de notre programme.
La sortie affiche les paires clé-valeur restantes dans « std :: map » après l'effacement de l'élément avec la clé 2 (« Bleu »), ce qui donne la sortie « 1 : Rouge » et « 3 : Vert ».
Exemple 2 : effacement par itérateur
En C++, les itérateurs sont des objets qui facilitent la navigation des éléments dans un conteneur, offrant un moyen d'accéder, de modifier ou de supprimer les éléments. La fonction « std::map::erase » peut également être utilisée avec des itérateurs pour supprimer les éléments.
Voici un exemple :
#include#include
int main ( ) {
std :: carte < int, std :: chaîne > dossier de fruits ;
dossier de fruits [ 1 ] = 'Mangue' ;
dossier de fruits [ 2 ] = 'Orange' ;
dossier de fruits [ 3 ] = 'Ananas' ;
dossier de fruits [ 4 ] = 'Raisins' ;
auto = fruitMap.find ( 2 ) ;
si ( il ! = fruitMap.end ( ) ) {
fruitMap.erase ( il ) ;
}
pour ( constante automatique & paire : fruitMap ) {
std :: cout << paire.premier << ' : ' << paire.seconde << std::endl;
}
retour 0 ;
}
Le code C++ fourni commence par déclarer un « std :: map » nommé « fruitMap » pour stocker les paires clé-valeur, associant les entiers aux noms de fruits correspondants. Nous remplissons la carte avec des entrées pour quatre fruits différents : « Mangue », « Orange », « PineApple » et « Raisins ». Après cela, nous utilisons la fonction « find » pour obtenir un itérateur (it) qui pointe vers l'élément avec la valeur clé de 2 dans le « fruitMap ». Ensuite, nous vérifions si l'itérateur n'est pas égal à « end() » pour nous assurer que l'élément avec la clé spécifiée existe dans la carte.
Dans le bloc conditionnel, nous effaçons l'élément pointé par l'itérateur « it » à l'aide de la fonction « effacer ». Enfin, nous parcourons les éléments restants du « fruitMap » modifié à l’aide d’une boucle « for ».
La sortie finale affiche le contenu modifié de « fruitMap » après l'effacement.
Exemple 3 : effacer une plage
Le conteneur « std :: map » en C++ fournit une méthode pratique pour effacer les éléments dans une plage spécifiée. La fonction « effacer » permet de supprimer les éléments de la carte en fonction d'itérateurs qui représentent le début et la fin de la plage à supprimer.
Explorons maintenant le concept d'effacement d'une plage à l'aide de « std::map » avec un exemple :
#include#include
int main ( ) {
std :: carte < int, std :: chaîne > nouvelleCarte ;
nouveauCarte [ 1 ] = 'Cheval' ;
nouveauCarte [ 2 ] = 'Lion' ;
nouveauCarte [ 3 ] = 'Tigre' ;
nouveauCarte [ 4 ] = 'Chat' ;
newMap.erase ( newMap.lower_bound ( 2 ) , newMap.upper_bound ( 3 ) ) ;
pour ( constante automatique & paire : newMap ) {
std :: cout << paire.premier << ' : ' << paire.seconde << std::endl;
}
retour 0 ;
}
Le programme commence par déclarer un « std :: map » nommé « newMap » qui associe les clés entières aux valeurs de chaîne correspondantes. Après cela, nous remplissons la carte avec des paires clé-valeur à l'aide de l'opérateur crochet. Par exemple, nous attribuons les paires clé-valeur de (1, « Cheval »), (2, « Lion »), (3, « Tigre ») et (4, « Chat ») à « newMap ».
La prochaine opération importante consiste à utiliser les itérateurs pour effacer les éléments de la carte. La fonction d'effacement est utilisée avec les arguments « newMap.lower_bound(2) » et « newMap.upper_bound(3) ». Cela efface les éléments dont les clés se situent dans la plage (2, 3). En d’autres termes, il supprime les entrées « Lion » et « Tigre » de la carte. Après cette opération, la carte ne contient que les éléments avec les clés 1 et 4, correspondant à « Cheval » et « Chat ».
Enfin, nous utilisons une boucle « for » basée sur une plage pour parcourir les éléments restants de la carte et imprimer leurs paires clé-valeur sur la console.
En conséquence, la sortie affiche ce qui suit :
Exemple 4 : effacement basé sur un prédicat
L'effacement basé sur un prédicat fait référence à la suppression des éléments d'une structure de données, telle qu'un conteneur, en fonction d'une condition ou de critères spécifiés. Le « std::map::erase » peut également être utilisé avec une fonction de prédicat pour supprimer les éléments de manière conditionnelle. Considérons l'exemple suivant :
#include#include
#include
int main ( ) {
std :: carte < int, std :: chaîne > maCarte = {
{ 1 , 'Janvier' } ,
{ 2 , 'Février' } ,
{ 3 , 'Mars' } ,
{ 4 , 'Avril' } ,
{ 5 , 'Peut' }
} ;
prédicat automatique = [ ] ( const std :: paire < int, std :: chaîne >& élément ) {
retour élément.seconde.longueur ( ) < 5 ;
} ;
maCarte.effacer ( std ::remove_if ( maCarte.begin ( ) , maCarte.end ( ) , prédicat ) , maCarte.end ( ) ) ;
std :: cout << ' \n Mapper après avoir effacé les éléments en fonction du prédicat :' << std::endl;
pour ( constante automatique & paire : maCarte ) {
std :: cout << paire.premier << ' : ' << paire.seconde << std::endl;
}
retour 0 ;
}
Le programme commence par inclure les fichiers d'en-tête nécessaires. Un « std::map » appelé « myMap » est déclaré et initialisé dans la fonction « main ». Il contient les paires clé-valeur qui représentent les noms des mois et leurs valeurs numériques respectives. Par la suite, une fonction « lambda » (prédicat) est définie. Cette fonction « lambda » sert de prédicat à l'algorithme « std::remove_if ». Il vérifie si la longueur de la valeur de chaîne associée à un élément de carte est inférieure à cinq caractères.
L'algorithme « std ::remove_if » est ensuite utilisé en conjonction avec la fonction « effacer » du « std :: map ». Cette combinaison supprime les éléments de la carte en fonction de la validité du prédicat.
Après avoir exécuté le programme, les éléments avec des clés inférieures à cinq sont supprimés de la carte originale, démontrant l'effacement basé sur un prédicat utilisant « std :: map ».
Conclusion
En conclusion, la fonction « std::map::erase » est un outil polyvalent en C++ pour supprimer les éléments de « std :: map ». Qu'il s'agisse d'un effacement par clé, itérateur, plage ou basé sur un prédicat, la fonction « std::map::erase » offre flexibilité et facilité d'utilisation. En maîtrisant cette fonction, les développeurs C++ peuvent gérer et manipuler efficacement les données dans les conteneurs « std::map », rendant leur code plus fort et plus facile à maintenir.