Emplace de la carte C ++

Dans C ++, EMPlace () et INSERT () Fonctionnez une chose similaire. Lorsque le programmeur ne se soucie pas des avantages de l'emplacement, il peut utiliser INSERT (). Emplace construit l'élément d'intérêt dans le conteneur d'intérêt tout en insérant des copies de l'élément de quelque part ou en déplaçant l'élément dans le conteneur d'intérêt.

Notion de copie

Considérez les deux listes de caractères suivantes:

liste la = 'a', 'b', 'c', 'd';
liste lb = 'e', 'f', 'g', 'h';

`` G '' en lb peut être copié et placé devant «D» à LA, pour avoir,

liste la = 'a', 'b', 'c', 'g', 'd';
liste lb = 'e', 'f', 'g', 'h';

Déplacer la notion

'G' en lb peut être retiré et placé devant 'D' à LA, pour avoir,

liste la = 'a', 'b', 'c', 'g', 'd';
liste lb = 'e', 'f', 'h';

Valeur dans l'élément

La copie et le déménagement ne sont pas aussi francs que ci-dessus. Dans une situation réelle, chaque valeur (e.g., caractère) est dans un élément. Donc, si une liste de Chars a quatre caractères, alors la liste a quatre éléments. Si une liste de Chars a trois caractères, alors la liste a trois éléments.

Un élément peut être une structure avec 3 membres de données. Le premier membre de données est un pointeur qui pointe vers l'élément précédent de la liste. Le deuxième membre de données détient la valeur, dans ce cas, le caractère. Le troisième membre de données est un pointeur qui pointe vers l'élément suivant de la liste.

Ainsi, chaque caractère, comme «g» ci-dessus, serait détenu par le deuxième membre de données d'une structure. Dans le cas de la liste d'origine, LB ci-dessus, et pour «G», le premier membre de données de la structure, pointerait vers l'élément qui a «F», et le troisième membre de données de la structure pointerait vers l'élément qui a 'h'.

Insérer et relancer

Lorsque insert () doit copier comme exprimé ci-dessus, l'élément de «g», je.e., La structure complète, sera copiée et placée devant l'élément «D», en théorie. En pratique, une fois qu'un nouvel élément correspondant est considéré comme placé devant l'élément «D», le troisième membre de données de la structure du nouveau G sera fait pour indiquer l'élément «D»; Et le premier membre de données de la nouvelle structure de G sera fait pour pointer de l'élément «C» (de List la).

Lorsque insert () doit se déplacer comme exprimé ci-dessus, la copie comme expliqué ici est effectuée, alors l'élément 'G' dans la liste LB est supprimé.

Emplace (), en revanche, n'a pas vraiment à copier ou à déplacer un élément. Il faut simplement indiquer au programme que la valeur d'intérêt est le caractère «g». Le programme construira ensuite un nouvel élément avec «G» comme valeur devant l'élément «D» dans la liste, LA. Autrement dit, il créera une nouvelle structure «G» devant l'élément «D», avec le troisième membre de données pointant vers l'élément «D» et le premier membre de données pointant vers l'élément «C», dans le cadre de l'élément de l'élément procédure de construction.

Ainsi, la principale différence entre insert () et emplace () est qu'EMPlace () construit l'élément d'insertion sur place, tandis que INSERT () doit copier ou déplacer l'élément.

Cet article explique ce qu'est la carte et comment utiliser les deux fonctions des membres principaux de l'emplacement de la carte.

Contenu de l'article

• L'élément de carte
• a_uniq.EMPLACE (ARGS)
• un.EMPLAY_HINT (P, Args)
• Conclusion

L'élément de carte

Voici quatre noms de fruits et leurs couleurs extérieures:

banane => jaune
Fruit de la passion => violet
pastèque => vert
raisin => rose

Une carte se compose de paires de clés / valeur. Dans cette liste ordinaire, les noms des fruits sont les clés, et les noms des couleurs extérieures sont les valeurs. Cependant, il s'agit d'une liste de paires, pas d'une liste de valeurs seules, et pas une liste de clés seules. C'est une liste de paires de clés / valeur. Les clés d'une carte sont uniques.

Dans le code, une clé et sa valeur sont codées comme un élément, appelé une paire. Chaque élément serait indiqué par un itérateur. Ainsi, un élément de carte voit une clé comme une valeur, et la clé correspond à une autre valeur. Ainsi, un élément de carte a besoin de deux valeurs pour créer un élément; Pas un comme exprimé dans l'introduction ci-dessus. Ces deux valeurs sont dans un code, appelé une paire.

Le modèle de l'élément de carte est:

paire

Le premier paramètre est pour la clé, et il est indiqué comme clé_type. Le deuxième paramètre est pour la valeur qui correspond à la clé. Il est indiqué comme mappé_type et non value_type. Value_Type est en fait:

paire

le modèle d'élément. Avec le tableau, les index sont aux valeurs. Avec la carte, les itérateurs sont aux paires. Une paire est une valeur, qui peut être maintenue par le deuxième membre de données d'une structure, et le troisième membre de données pointant vers l'élément suivant, qui a également une paire comme valeur; et le premier membre de données pointant vers l'élément précédent, dont la valeur est une autre paire.

Dans la liste des fruits / couleurs ci-dessus, la première paire peut être codée comme suit:

"banane", "jaune"

«Banana» est la clé, et «jaune» est la valeur, formant une paire clé / valeur. L'ensemble de la liste restreinte de deux valeurs est une valeur de valeur_type et peut être maintenue par l'élément de données intermédiaire d'un élément struct. Le premier membre de données de la structure pointera vers l'élément précédent, et le troisième membre de données de la structure pointera vers l'élément suivant.

Maintenant, une paire est un objet dont la clé a d'abord le nom du membre et dont la valeur a le nom du membre deuxième.

Le programme suivant met la liste ci-dessus des fruits / couleurs dans une carte:

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

carte mp = "banane", "jaune", "Passion Fruit", "Purple", "Watermelon", "Green", "Grape", "Pink";
pour (carte:: iterator it = MP.commencer(); il != MP.fin(); it ++)
couter << it->d'abord << " => " << it->deuxième << endl;
retour 0;

La sortie est:

banane => jaune
Fruit de la passion => violet
pastèque => vert
raisin => rose

Notez que la bibliothèque de cartes devait être incluse.

Paire hétérogène

Une paire ne doit pas nécessairement avoir une clé et une valeur qui ont du sens pour l'utilisateur ordinaire. Il peut également avoir une clé et une valeur qui n'ont pas de sens pour l'utilisateur ordinaire mais qui a du sens pour le programmeur. À titre d'exemple pour une paire de touches / valeur qui a du sens pour le programmeur, la clé peut être un itérateur et la valeur, un type bool.

a_uniq.EMPLACE (ARGS)

Ici, a_uniq est le nom de la carte. Les args sont la clé et la valeur de la paire, séparées par une virgule. La fonction membre renvoie une paire, dont la première valeur est un iterator (valeur_type); et dont la deuxième valeur est un bool, pour indiquer si l'insertion (construite sur place) a réussi (vrai pour le succès). L'itérateur retourné pointe vers l'élément inséré. La spécification C ++ n'indique pas où l'insertion doit avoir lieu dans la liste (ou devant ou derrière) pour cette fonction. Le programme suivant illustre l'utilisation de la fonction:

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

carte mp = "banane", "jaune", "Passion Fruit", "Purple", "Watermelon", "Green", "Grape", "Pink";
paire:: iterator, bool> pr = mp = mp =.EMPLACE ("Strawberry", "Red");
couter << (pr.first)->d'abord << " => " << (pr.first)->deuxième << " : " << pr.second << endl;
couter << endl;
pour (carte:: iterator it = MP.commencer(); il != MP.fin(); it ++)
couter << it->d'abord << " => " << it->deuxième << endl;
retour 0;

La sortie est:

Strawberry => rouge: 1
Strawberry => rouge
banane => jaune
Fruit de la passion => violet
pastèque => vert
raisin => rose

1 dans la première ligne de sortie signifie vrai. Notez comment les args ont été codés («fraises», «rouge»). Ne confondez pas entre valeur_type et mappé _Type.

un.EMPLAY_HINT (P, Args)

Ici, «A» est le nom de la carte. Cette fonction membre est similaire à ce qui précède, mais la position où la mise en place doit avoir lieu dans la liste des cartes est suggérée. C'est un itérateur, P pointant vers l'élément avant, et près de quoi, l'insertion (mise en place) sera placée, en mémoire. La fonction renvoie un itérateur et non une paire. L'itérateur pointe vers l'élément nouvellement inséré (paire). Le programme suivant illustre ceci:

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

carte mp = "banane", "jaune", "Passion Fruit", "Purple", "Watermelon", "Green", "Grape", "Pink";
carte:: iterator p = mp.fin();
P--;
carte:: iterator iter = MP.EMPlace_Hint (P, "Strawberry", "Red");
couter << iter->d'abord << " => " << iter->deuxième << endl;
couter << endl;
pour (carte:: iterator it = MP.commencer(); il != MP.fin(); it ++)
couter << it->d'abord << " => " << it->deuxième << endl;
retour 0;

La sortie est:

Strawberry => rouge
Strawberry => rouge
banane => jaune
Fruit de la passion => violet
pastèque => vert
raisin => rose

Conclusion

Emplacer et insérer sont similaires. Emplace construit son élément sur place dans la liste, après avoir obtenu la valeur, en quelque sorte. D'un autre côté, insérez les copies de son élément dans la liste à partir d'un endroit ou déplace l'élément dans la liste de quelque part.

Remarque: une carte est normalement créée triée par des clés. Pour y parvenir pour la carte ci-dessus, utilisez des objets de chaîne pour les touches au lieu des pointeurs constantes.