C ++ multimap

Aujourd'hui, nous en apprendre davantage sur le multimap et pourquoi nous utilisons le multimap. Nous apprendrons l'implémentation de l'écriture et les fonctions importantes du multimap à travers des exemples détaillés. Mais, avant de sauter sur le multimap, nous apprendrons les bases de la carte en C ++ afin qu'il soit facile d'apprendre comment le multimap fonctionnera.

En C ++, les cartes sont les conteneurs qui stockent les éléments de données dans les paires de valeurs clés. Dans les cartes, ces paires de valeurs clés conservent des éléments de données. Cela signifie que chaque clé a sa valeur d'élément, mais la clé doit être unique pour être accessible rapidement. Par défaut, les paires de valeurs clés sont organisées en ordre trié.

Introduction

En C ++, les multimaps sont le conteneur qui conserve les éléments dans les paires de valeurs clés de manière organisée afin qu'ils puissent fonctionner efficacement et rapidement. Ces valeurs clés sont utilisées pour organiser les éléments et identifiés de manière unique afin que le contenu lié à cette clé soit stocké en valeurs mappées. La seule différence significative entre le multimap et la carte est la possibilité de clés répétées qui ne sont pas uniques, et il utilise le «<” operator to compare the keys.

Syntaxe

Dans MultiMap STL, nous écrivons le mot clé «modèle» pour passer le type de données en tant que paramètre afin que nous n'ayons pas à écrire le code pour chaque type de données, puis à écrire le «» plus grand que l'opérateur pour fermer la classe multimap.

Paramètres

clé: est utilisé pour dire le type de clé pour stocker la clé dans un multimap.

taper: est utilisé pour dire le type de données de la valeur mappée dans un multimap.

comparer: est un paramètre facultatif, et il vous permet de comparer deux valeurs d'élément en tant que touches de tri pour déterminer comment elles doivent être organisées dans le multimap. Par défaut, le prédicat binaire est moins utilisé.

alloc: est utilisé pour allouer les valeurs dans le multimap.

Exemple

Voici un exemple simple du multimap. Commençons par décrire la mise en œuvre de l'exemple et comprenons également ce que nous avons fait dans cet exemple. Mais, avant cela, nous avons besoin d'un compilateur C ++ où nous écrivons et exécutons l'exemple de code. Alors, ouvrez le compilateur C ++.

Y compris les bibliothèques de base

Dans chaque programme de C ++, nous devons inclure les bibliothèques importantes et de base liées à notre programme afin que nous n'ayons pas besoin d'écrire le code de la fonction prédéfinie de C++. En utilisant des packages, notre code sera précis et facile à comprendre, et il compilera également efficacement. Nous écrivons le signe «#» pour chaque package qui ordonne au compilateur de charger le fichier d'en-tête. Ensuite, nous écrivons le mot-clé «inclure» afin que le compilateur comprenne que nous incluons n'importe quel package en C++. Ensuite, nous ouvrons l'opérateur «».

Dans cet exemple, nous avons utilisé trois bibliothèques; «IOStream» saisit les données de l'utilisateur et affiche les données à l'utilisateur. La seconde est «String», donc si nous utilisons une valeur de chaîne dans l'ensemble du programme, nous devons inclure le package de chaîne, et le troisième est «Map» parce que nous utilisons des techniques de mappage dans notre programme.

#inclure
#inclure
#inclure
Utilisation de Namespace Std;

Déclarer et initialiser les paires de valeurs clés

Ensuite, nous écrivons la fonction principale () dans le programme afin que nous puissions écrire la ligne de code réelle que nous voulons implémenter. Tout d'abord, nous déclarerons le tuple multimap nommé «Mulmap» de la paire de valeurs clés «int» et «string» et initialisez certaines données dedans. Pour la chaîne, nous écrivons les données en double guillemets. Ensuite, nous vérifions la taille du tuple «Mulmap» en utilisant la fonction de taille () prédéfinie concaténée avec «Mulmap», puis affichons la taille en utilisant la méthode COUT () prédéfinie. Pour afficher les éléments d'un tuple un par un, nous avons appelé «For Loop».

int main()

multimap Mulmap =
1, "Islamabad",
2, "Lahore",
3, "Multan",
4, "Karachi"
;
couter << "The size of multimap is: " << mulmap.size()
<couter << "Elements in multimap are: " << endl;
couter<<"\tKEY\t\tELEMENT\n";
pour (Auto iTr: Mulmap)
couter << "\t" << itr.first <<"\t\t"<< itr.second << endl;

Voici la sortie de la partie précédente du code. Comme vous le voyez, nous avons maintenant la taille du tuple multimap et les éléments des paires de valeurs clés.

Insertion de nouvelles données en utilisant la fonction insert ()

Après avoir déclaré le multimap, nous voulons implémenter l'une des fonctions du multimap, qui est la fonction insert (). Comme nous avons déjà inséré certaines données dans le tuple multimap, nous voulons insérer de nouvelles données. Pour cela, nous allons écrire le nom de tuple multimap, «Mulmap», puis concaténer la fonction insert () avec lui. Dans les supports Mulmap, écrivez le mot-clé «maquilleur» parce que nous passons des données sous forme de paire dans MultiMap, puis écrivons la nouvelle paire dans laquelle nous voulons insérer des données dans le tuple «Mulmap» existant.

Et puis, nous avons utilisé «pour Loop» pour afficher les valeurs dans la coque une par une dans l'ordre trié. Après avoir imprimé les paires de valeurs clés, nous voulons vérifier à nouveau la taille du tuple «Mulmap» mis à jour, nous avons donc à nouveau utilisé la fonction SIZE () et passé la fonction SIZE () dans la méthode cout () afin que nous puissions Affichez la taille du «Mulmap» à l'utilisateur.

couter << "\nInserting New Elements in Multimap: " << endl;
couter<<"\tKEY\t\tELEMENT\n";
mousse.insérer (Make_pair (0, "RawalPindi"));
mousse.insérer (Make_pair (5, "Hyderabad"));
pour (Auto iTr: Mulmap)
couter << "\t" << itr.first <<"\t\t"<< itr.second << "\t" << endl;

couter <<"Elements in multimap after updating: " << mulmap.size() << endl;

Examinons la sortie de l'extrait de données précédent sur MultiMap, où nous avons inséré de nouvelles données. Comme vous le voyez, les paires de valeurs clés sont affichées de manière organisée. Et après avoir mis à jour les paires de valeurs clés, nous avons la taille du multimap comme 6.

Supprimer les données du multimap en utilisant la fonction efface ()

Pour éliminer les éléments de données du tuple du mulmap, nous utilisons la fonction ERASE () et passons la fonction dans la méthode cout () afin que nous puissions afficher le tuple «Mulmap» après avoir retiré les éléments du tuple. Là encore, nous vérifions la taille du tuple «Mulmap» en utilisant la fonction de taille ().

couter<<"\nRemoving elements from multimap: \n";
couter<<"\tKEY\t\tELEMENT\n";
mousse.Effacer (Mulmap.begin (), Mulmap.trouver (4));
pour (Auto iTr: Mulmap)
couter << "\t" << itr.first <<"\t\t"<< itr.second << "\t" << endl;

couter <<"Elements in multimap after removing: " << mulmap.size() << endl;

Voici la sortie de la partie illustrée, que nous avons implémentée ci-dessus. Comme indiqué ci-dessous, la taille du tuple «Mulmap» est de 2:

Vérifiez la limite supérieure du tuple du mulmAP existant

Pour vérifier le premier élément du tuple mis à jour de «MultiMap», nous utiliserons la fonction Upper_Bound () et passerons la valeur clé à la fonction.

Couter << “\nElement on the Upper bound of multimap is: “ << endl;
couter<<”\tKEY\t\tELEMENT\n”;
couter << “\t” << mulmap.upper_bound(0)->d'abord << “\t\t” << mulmap.upper_bound(0)->deuxième << endl;

Comme vous l'avez vu, nous avons transmis une valeur 0 à la fonction upper_bound (). Cependant, nous avons la limite supérieure de l'élément clé 4 car maintenant le tuple «Mulmap» ne contient que deux éléments clés, et le supérieur est affiché ci-dessous:

Vérifiez la borne inférieure dans le tuple du mulmAP existant

Maintenant, vérifions le dernier élément du tuple "Mulmap" en utilisant la fonction Lower_Bound () du multimap et l'impression via la méthode cout ().

couter << "\nElement on the lower bound of multimap is: " << endl;
couter<<"\tKEY\t\tELEMENT\n";
couter << "\t" << mulmap.lower_bound(5)->d'abord << "\t\t" << mulmap.lower_bound(5)->deuxième << endl;

Voici la sortie de la limite inférieure du tuple «Mulmap»:

En fin de compte, nous retournerons 0 à la fonction Main () et fermerons les accolades bouclées:

Conclusion

Dans cet article, nous avons appris le multimap en mettant en œuvre des exemples simples avec des explications détaillées. Nous avons discuté du style d'écriture du multimap. Nous avons également appris certaines des fonctions importantes du multimap en C ++ avec une explication détaillée de chaque ligne de code.