Définir VS Map en C ++

Le but de cet article est de donner les similitudes et les différences entre un ensemble et une carte. «VS» dans le titre signifie «versus». Tout d'abord, qu'est-ce qu'un ensemble? - Un ensemble en C ++ est comme l'ensemble en mathématiques. En C ++, un ensemble est un groupe de valeurs non nécessairement non liées, mais du même type. Les valeurs d'un ensemble sont appelées clés en c++.

Qu'est-ce qu'une carte? - Une carte est un ensemble de paires de clés / valeur. En C ++, les clés sont du même type, et les valeurs sont également du même type. Il y a un multiset et il y a du multimap. Un multiset est un ensemble où les valeurs ne sont pas uniques; c'est-à-dire qu'il peut y avoir plus d'une des mêmes valeurs. N'oubliez pas que les valeurs de l'ensemble sont appelées clés en c++. Sur une carte, certaines des valeurs peuvent être les mêmes, mais les clés doivent être différentes (uniques). Dans un multimap, il peut y avoir plus d'une clé, qui sont les mêmes.

Le titre de cet article est «Set vs Map en C ++». Ainsi, le multiset et le multimap ne sont pas pris en compte dans cet article; Seuls set et la carte sont comparés et contrastés.

Chaque fois qu'une clé est insérée dans un ensemble, l'ensemble est ré-tripoté. Remarque: un ensemble en C ++ peut également avoir des paires de clés / valeur; Et ce n'est pas une vision mathématique de l'ensemble. - Pourtant, en C ++, un ensemble peut avoir des paires de clés / valeur. Ainsi, chaque fois qu'une paire de clés / valeur est insérée dans un ensemble, l'ensemble est re-sortant par des clés. D'un autre côté, une carte par définition se compose de paires de clés / valeur où les clés n'ont pas de double. Avec la carte aussi, chaque fois qu'une paire de clés / valeur est insérée dans la carte, la carte est réinstallée par les clés. L'ensemble et la carte sont les mêmes à cet égard.

L'ensemble et la carte ont chacun la spécialisation du modèle de comparaison. Tous deux sont des conteneurs associatifs. Pour l'un d'eux, afin que la structure de données soit triée en ascendance, utilisez la spécialisation du modèle de comparaison, moins, remplacer la «clé», par le type de clé. Pour l'un d'eux, afin que la structure de données soit triée descente, utilisez la spécialisation du modèle de comparaison, plus grande, en remplacement de la «clé», par le type de clé. Pour les deux, moins est la valeur par défaut.

Pour les deux structures de données, les fonctions membres sont des catégories dans les catégories suivantes: constructions (y compris la copie et l'attribution), les itérateurs, les modificateurs, les observateurs, les opérations et l'échange. Dans toutes ces catégories, les fonctions membre pour l'ensemble et la carte sont similaires.

La structure de données définie n'a pas la catégorie d'accès des éléments, mais la carte. La catégorie d'accès aux éléments se compose des opérateurs de crochets et des fonctions de membres AT () qui sont utilisées comme les homologues du vecteur. Ils sont utilisés pour accéder (scan) chacun des éléments de la carte. L'ensemble n'a pas ces opérateurs ou ces fonctions. Pour l'ensemble, les éléments sont accessibles en utilisant des itérateurs. Les éléments sont également accessibles pour la carte en utilisant des itérateurs similaires.

Ci-dessus sont les principales similitudes et différences pour l'ensemble et la carte. La particularité de cette comparaison est avec l'utilisation de paires de clés / valeur. La paire clé / valeur est de la structure appelée paire dans la bibliothèque d'utilité C ++. Le reste de cet article donne une brève description de la façon dont la paire est utilisée à la fois dans l'ensemble et la carte, en commençant par ce qu'est une paire:

Paire

La syntaxe d'une paire littérale est:

valeur clé

Une série de telles paires se composerait d'un ensemble ou d'une carte est:

"citrons", 8
"oranges", 5
"Pears", 12

Cela représente une structure de données des fruits et leurs nombres trouvés dans un panier. La clé pour chaque paire est le type de chaîne; Et la valeur pour chaque paire est le type entier. Le programme suivant construit trois paires différentes de la même valeur_type, string / int:

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

paire pr1 = "citrons", 8;
paire pr2 = "oranges", 5;
paire pr3 = "Pears", 12;
retour 0;

Notez que la bibliothèque utilitaire a été incluse. Les noms des paires sont PR1, PR2 et PR3. Ils sont de la même valeur_type, String / int.

La clé / valeur d'une paire ne doit pas nécessairement être une chaîne / int. Il peut être itérateur / bool avec la syntaxe littérale:

iterator, bool

Dans un objet de paire, Bool est vrai ou faux, et itérateur est le nom de l'itérateur. C'est ce type de paire qui est renvoyé lorsqu'une paire de clé / valeur, comme une paire de chaînes / int, est insérée dans un ensemble ou une carte. Le composant bool est vrai, si et seulement si l'insertion de la paire a eu lieu. Le composant itérateur pointe vers l'élément inséré particulier (clé et valeur) dans son ensemble.

La clé d'une paire est nommée «First» en C ++; Et la valeur de la paire est nommée «deuxième».

Définir et cartographier les constructions

Ensemble
Un ensemble vide de paires String / int serait construit comme suit:

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

ensemble> st;
retour 0;

La spécialisation du modèle clé est «paire», et elle est considérée comme un seul composant. Le seul composant fait référence à la paire (de clé / valeur).

Carte
Une carte vide des paires String / int serait construite comme suit:

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

carte MP;
retour 0;

Ici, la spécialisation du modèle commence par la clé puis la valeur. La spécialisation du modèle de clé est «String» et la spécialisation du modèle de valeur est «int». Il y a deux composants pour la carte, qui sont la clé et la valeur. Pour l'ensemble, il y a un composant qui se compose de deux composants internes. Notez la différence.

Insertion

Ensemble
Le code de fonction C ++ Main () suivant montre comment les paires peuvent être insérées dans un ensemble et imprimé (affiché à l'écran):

paire pra = "Pears", 12, prb = "oranges", 5, prc = "citrons", 8;
ensemble> st;
St.insérer (PRA); St.insérer (PRB); St.insérer (PRC);
pour (ensemble> :: iterator iter = st.commencer(); iter != st.fin(); iter ++)
couter << iter->d'abord << " => " << iter->deuxième << endl;

La sortie est:

citrons => 8
oranges => 5
Pears => 12

Notez que bien que les paires de clés / de valeur n'aient pas été insérées dans l'ordre croissant par des clés, les éléments où les clés sont triées en interne. L'ensemble triera toujours ses éléments par les clés, qu'ils soient des paires ou non.

Carte
Le code de fonction Main () suivant montre comment les paires peuvent être insérées dans une carte et imprimées (affichées à l'écran):

paire pra = "Pears", 12, prb = "oranges", 5, prc = "citrons", 8;
carte MP;
député.insérer (PRA); député.insérer (PRB); député.insérer (PRC);
pour (carte:: iterator iter = MP.commencer(); iter != MP.fin(); iter ++)
couter << iter->d'abord << " => " << iter->deuxième << endl;

La sortie est:

citrons => 8
oranges => 5
Pears => 12

Bien que les paires de clés / de valeur n'aient pas été insérées dans l'ordre croissant par des clés, les éléments où les clés sont triées en interne. La carte triera toujours ses éléments par les clés.

Conclusion

Les similitudes et les différences entre un ensemble et une carte en C ++ sont facilement appréciées à partir de leurs différentes définitions. La particularité apparaît lorsqu'il s'agit de paires. En C ++, un ensemble peut avoir des paires, ce qui n'est pas vraiment ce que les mathématiques suggèrent. Même ainsi, le programmeur doit savoir comment gérer les paires pour un ensemble et pour une carte.