Fonctions de carte C ++

«Les cartes sont des conteneurs associatifs qui sont utilisés pour stocker des objets de manière mappée. Chaque clé d'une paire de valeurs de clé contenant tous les composants d'une carte est distincte. Les clés sont utilisées pour la commande, mais chaque clé a un ensemble de valeurs connexes. Des données peuvent être ajoutées et supprimées en cas de besoin. Dans le langage de programmation C ++, les cartes maintiennent des éléments créés en combinant une valeur clé et une valeur définie.

À deux fins principales, les programmeurs C ++ peuvent trouver la structure de la carte utile. Tout d'abord, en utilisant la clé, une carte permet une accessibilité rapide et facile à la valeur. La création de tout type d'index ou de pointeur peut bénéficier de cet attribut. Une clé doit être unique dans le cadre de données intégré, que la carte fournit à faire. Cela empêche la duplication des données; Par conséquent, c'est un autre avantage de l'utilisation de la carte.

Par exemple, si vous créez une application de trading et que vous devez conserver les valeurs des actifs par signe de ticker, une carte est une approche utile en raison de ces deux avantages. Une carte serait une méthode efficace pour fournir et vérifier la météo existante dans de nombreuses villes du monde entier si nous avions développé une application météorologique. Nous utiliserons probablement une carte sur un marché en ligne pour localiser les produits par des marques ou des catégories."

Quand éviter d'utiliser une carte C ++?

La fonction de carte de C ++ convient pour localiser efficacement les valeurs par clé. Mais, trouver des éléments de la carte par l'utilisation d'un entier implique la traversée une seule fois la carte complète. L'itération d'une carte pourrait devenir du temps à mesure qu'une carte augmente si nous voulions pouvoir y localiser des valeurs. Une carte bidirectionnelle est fournie par le module Boost, ce qui le rend plus efficace lorsque nous récupérons fréquemment les données. Étant donné que le module C ++ standard ne contient pas ce modèle de données, l'utilisateur doit soit acquérir la bibliothèque Boost sur chaque ordinateur où le programme est exécuté ou intégrer le package Boost dans le cadre de la liaison statique.

Une carte n'est peut-être pas la meilleure structure à utiliser si nous réalisons que nous devons trouver une carte par élément dans une application simple. Utilisez un tableau C ++, un tampon, une pile ou tout autre type de données qui pourrait rendre l'application plus facile à comprendre et plus efficace.

Discutons du fonctionnement des fonctions de carte en C++.

Exemple n ° 1

Nous exécuterons le code dans ce cas pour montrer comment implémenter les fonctions de carte. Nous pouvons itérer les composants de la carte. Pour ce faire, nous devons seulement construire un itérateur, puis l'utiliser.

#inclure
#inclure
#inclure
Utilisation de Namespace Std;
int main()

carte affectation1;
affectation1.insérer (paire(2, 60));
affectation1.insérer (paire(4, 80));
affectation1.insérer (paire(6, 70));
affectation1.insérer (paire(8, 90));
affectation1.insérer (paire(10, 50));
affectation1.insérer (paire(12, 80));
affectation1 [14] = 40;
carte:: iterator itr;
couter << "\nThe map of the assignment1 is : \n";
couter << "\tKEY\tELEMENT\n";
pour (itr = affectation1.commencer(); itr != affectation1.fin(); ++ itr)
couter << '\t' << itr->d'abord << '\t' << itr->deuxième
<< '\n';

couter << endl;
carte affectation2 (affectation1.begin (), affectation1.fin());
couter << "\nThe map of the assignment2 after"
<< " assign from assignment1 is : \n";
couter << "\tKEY\tELEMENT\n";
pour (itr = affectation2.commencer(); itr != affectation2.fin(); ++ itr)
couter << '\t' << itr->d'abord << '\t' << itr->deuxième
<< '\n';

couter << endl;

Ici, nous allons intégrer les fichiers d'en-tête requis. et au début du code. Maintenant, nous invoquons la fonction principale (). Nous utiliserons la commande de carte. Dans cette commande, nous initialisons deux entiers. Maintenant, nous devons insérer différentes valeurs aléatoires d'éléments. Nous avons donc utilisé la fonction insert ().

L'argument «paire» aura deux entiers. Nous spécifions les valeurs de 6 affectations différentes. Nous devons maintenant utiliser une autre méthode pour introduire la valeur dans une carte. Ensuite, nous imprimerons l'affectation de la carte en utilisant la commande de carte. Parallèlement à cela, nous utilisons un itérateur. La déclaration «cout» est utilisée pour imprimer la ligne. Ensuite, la déclaration «cout» sera utilisée pour montrer les clés et les éléments. Ensuite, nous faisons une augmentation de la valeur de «ITR». Ensuite, nous utiliserons la déclaration «cout». Nous avons créé un pointeur qui pointe vers l'itérateur. Nous utiliserons le terme «endl» pour faire du codage dans la ligne suivante.

Maintenant, nous allons attribuer les éléments de l'affectation1 à l'affectation2. Nous utiliserons à nouveau la commande map. Parallèlement à cela, nous utilisons l'affectation de la fonction début () et end (). Ces fonctions sont utilisées pour démarrer et résilier les valeurs de l'affectation1. Maintenant, nous allons démontrer tous les éléments de la carte nécessaire. L'instruction «cout» sera appliquée pour imprimer la ligne «La carte de l'affectation2 après l'attribution de l'affectation1 est». Ensuite, «cout» est utilisé pour montrer les clés et les éléments.

Encore une fois, nous appliquons la boucle «pour». Nous devons satisfaire la condition. Ensuite, nous faisons une augmentation de l'itérateur. Nous allons construire le pointeur des premier et deuxième éléments de l'affectation1. Pour démarrer le code à partir de la nouvelle ligne, nous utilisons «endl». Nous allons maintenant supprimer tous les éléments jusqu'à l'élément ayant la valeur de clé «3» en affectation1.

couter << "\nassignment2 after eliminating the "
"Éléments ayant la valeur clé de moins de 3: \ n";
couter << "\tKEY\tELEMENT\n";
affectation2.Effacer (affectation2.begin (), affectation2.trouver (3));
pour (itr = affectation2.commencer(); itr != affectation2.fin(); ++ itr)
couter << '\t' << itr->d'abord << '\t' << itr->deuxième
<< '\n';

int n;
n = affectation2.effacer (4);
couter << "\nassignment2.erase(4) : ";
couter << n << " removed \n";
couter << "\tKEY\tELEMENT\n";
pour (itr = affectation2.commencer(); itr != affectation2.fin(); ++ itr)
couter << '\t' << itr->d'abord << '\t' << itr->deuxième
<< '\n';

couter << endl;
couter << "assignment1.lower_bound(10) : "
<< "\tKEY = ";
couter << assignment1.lower_bound(10)->d'abord << '\t';
couter << "\tELEMENT = " << assignment1.lower_bound(10)->deuxième
<< endl;
couter << "assignment1.upper_bound(10) : "
<< "\tKEY = ";
couter << assignment1.upper_bound(10)->d'abord << '\t';
couter << "\tELEMENT = " << assig>nment1.Upper_Bound (10) -> Deuxième
<< endl;
retour 0;

La déclaration «cout» est utilisée pour imprimer la déclaration «Affectation2 après avoir éliminé les éléments ayant la valeur clé inférieure à 3». La déclaration «cout» imprime également les clés et leurs valeurs. Nous avons appliqué la fonction effacer (). Ici, nous utilisons la méthode begin (). En raison de cette fonction, il commence les valeurs clés de l'affectation2. Ensuite, nous devons utiliser la méthode find () pour acquérir l'élément dans la carte. Nous utilisons la fonction début () et end (), qui est associée à l'itérateur. Ensuite, nous construisons le pointeur du premier et deuxième élément de l'itérateur et utilisons l'instruction «cout» pour imprimer ces valeurs.

Maintenant, nous voulons éliminer l'élément qui a une valeur clé 4. Ce faisant, nous devons initialiser la variable «n». Le type de données de cette variable est un entier. Ensuite, nous utiliserons la fonction effacer (). Cette fonction contient le paramètre de la valeur que nous voulons être supprimés. La déclaration «cout» sera utilisée pour supprimer cet élément. Encore une fois, nous utilisons la boucle «pour» et le pointeur de l'itérateur. Nous allons imprimer la limite inférieure et la limite supérieure de la carte pour l'affectation1 en utilisant l'instruction «cout».

Dans la ligne suivante, nous utiliserons l'instruction «cout» pour créer un pointeur qui pointe vers la deuxième valeur de l'affectation1. Nous entrons également le mot-clé «endl» pour passer à la ligne suivante pour le codage. Maintenant, la méthode Upper_Bound () d'attribution1 sera appelée. Le pointeur sera créé pour pointer la deuxième valeur de la limite supérieure de l'affectation1.

Exemple n ° 2

Dans cette illustration, la valeur clé et la valeur liée à la clé ont toutes deux des types de données différents. Il n'est pas possible de configurer les valeurs une à la fois; ils doivent être fournis par paires.

#inclure
#inclure
#inclure
#inclure
Utilisation de Namespace Std;
int main()

carte Ouvriers;
Travailleurs [221] = "Anikaa";
Travailleurs [320] = "Zeeshan";
Travailleurs [345] = "Daniyal";
Travailleurs [237] = "Dania";
Travailleurs [189] = "azka";
couter << "Workers[190]=" << Workers[237] << endl << endl;
couter << "Size of the map: " << Workers.size() << endl;
couter << endl << "The Original Order:" << endl;
for (map :: iterator jj = travailleurs.commencer(); JJ!= Travailleurs.fin(); ++ JJ)

couter << (*jj).first << ": " << (*jj).second << endl;

couter << endl << "The Inverse Order:" << endl;
pour (map :: reverse_iterator jj = travailleurs.rbegin (); JJ!= Travailleurs.déchirer(); ++ JJ)

couter << (*jj).first << ": " << (*jj).second << endl;

Au début du programme, nous inclurons quatre bibliothèques importantes, qui incluent ,, et . Après tout, l'espace de noms standard sera utilisé comme MST. Nous construisons la carte des travailleurs. Nous fournirons deux types de données comme arguments de la carte. Le type de données comprend un entier et une chaîne. Maintenant, nous allons attribuer les ID aux travailleurs respectivement. Nous utilisons le format d'index de tableau pour allouer les valeurs. La déclaration «cout» est utilisée pour montrer le nom du travailleur dont l'identification est 190.

De plus, nous avons utilisé l'instruction «cout» pour afficher la taille de la carte. La taille sera imprimée après la déclaration «Taille de la carte». Ensuite, l'instruction «cout» sera utilisée pour afficher l'ordre d'origine des IDS. À l'intérieur de Loop, nous utiliserons la commande «map». Nous initialisons la chaîne et l'itérateur. Ensuite, nous commençons la carte des travailleurs en utilisant la méthode Begin (). Pour terminer la carte des travailleurs, nous avons utilisé la fonction fin ().

Dans la dernière partie de la boucle «pour», nous avons augmenté la valeur de l'itérateur. La déclaration «cout» sera utilisée pour montrer les éléments de la carte. Ensuite, nous utiliserons à nouveau la déclaration «cout» pour afficher la ligne «l'ordre inverse». Nous utiliserons la méthode begin () et end () pour démarrer et résilier les éléments de la carte. Nous allons itérer les éléments jusqu'à ce que la condition soit remplie. En fin de compte, la déclaration «cout» est utilisée pour imprimer les éléments de manière inverse.

Exemple n ° 3

Quelques-unes des fonctions de carte sont utilisées dans le programme suivant. Avant d'itérer pour une telle valeur qui correspond à une clé spécifique, elle ajoute initialement d'autres éléments à la carte.

#inclure
#inclure
#inclure
#inclure
Utilisation de Namespace Std;
int main()

carte Std;
MST.insérer (std :: paire(736, "Jamil"));
MST.insérer (std :: paire(233, "Dua"));
MST.insérer (std :: paire(837, "Aima"));
Std [348] = "snobar";
Std [646] = "Tania";
couter << "Map Size: " << Std.size() << endl << endl;
couter << endl << "Real order of the values:" << endl;
pour (map :: iterator iter = std.commencer(); iter!= Std.fin(); ++ iter)

couter << (*iter).first << ": " << (*iter).second << endl;

STD :: Map:: iterator it = std.trouver (348);
si ça != Std.fin())
std :: cout < " << Std.find(348)->deuxième << '\n';

Tout d'abord, nous incorporerons les fichiers d'en-tête. Le fichier d'en-tête traite des chaînes du code. Le fichier d'en-tête traite des fonctionnalités d'entrée et de sortie. Le fichier d'en-tête traite de la carte. Et le dernier fichier d'en-tête traite des fonctionnalités des services publics. Commençons le codage dans le corps de la fonction principale () 0f. Nous exécuterons la commande «map». Avec l'aide de cela, nous initialiserons une carte par les clés et leurs valeurs appropriées. Le type de données des clés est un entier, et le type de données de leurs valeurs est «String».

Nous allons maintenant insérer les marques et les noms des étudiants sur la carte avec l'aide de la fonction insert (). Nous utilisons cette fonction pour ajouter les données des trois étudiants. Ensuite, nous utiliserons le format d'index de tableau pour insérer les marques et les noms des étudiants. Les données de deux étudiants seront insérées en utilisant le format d'index de tableau.

De plus, nous appliquerons la méthode «cout». L'instruction «cout» affiche la ligne «Taille de la carte» à l'écran avant la carte. Dans cette instruction «cout», nous utiliserons la méthode size (). Nous allons maintenant montrer les noms et les numéros des étudiants au format original. L'instruction «cout» est utilisée pour imprimer le texte «Ordre réel des valeurs». Nous utilisons la commande «endl» des deux côtés de ce texte pour imprimer ce texte sur une ligne séparée. Maintenant, nous utilisons la boucle «pour». Nous utiliserons également la fonction début () pour commencer à imprimer le prénom et les marques de l'élève sur une carte.

De même, la méthode fin () est utilisée pour montrer le nom de famille de l'élève sur une carte. La déclaration «cout» montrera ces premières et dernières valeurs. À la fin du programme, nous utiliserons une autre fonction de carte pour trouver (). Nous voulons découvrir le nom de l'étudiant, dont le numéro est 348. Nous appellerons donc la méthode find (). Nous utilisons STD :: Map et Std :: Iterator. Ensuite, nous avons utilisé la condition «IF». Nous appliquons la fonction de carte fin () pour remplir la condition «IF». Pour imprimer le nom de l'étudiant dont les marques sont 348, nous utiliserons la méthode std :: cout. Nous créons également le pointeur, qui pointe vers la deuxième valeur de la carte.

Conclusion

Nous avons discuté d'une carte C ++ et comment utiliser les fonctions de carte dans cet article. Nous avons brièvement démontré d'ajouter des éléments et de les récupérer par l'utilisation de la carte dans différents exemples. Les cartes sont le composant de la bibliothèque de modèles standard. Les cartes sont des récipients associatifs qui contiennent des paires de valeurs clés ordonnées; Presque toutes les touches sont distinctes et ne peuvent être ajoutées ou complètement supprimées. Les valeurs clés peuvent avoir leurs valeurs connexes qui seront modifiées. Dans une carte, les valeurs définies maintiennent les données relatives à la clé, tandis que les valeurs de clé sont généralement utilisées pour organiser et identifier des composants particuliers.