C ++ Map EmPlace

In C ++, eMplace () e insert () le funzioni fanno una cosa simile. Quando al programmatore non si preoccupa dei vantaggi che EmPlace ha, può usare Insert (). EmPlace costruisce l'elemento di interesse all'interno del contenitore di interesse mentre inserisce copie dell'elemento da qualche parte o spostando l'elemento nel contenitore di interesse.

Copia nozione

Considera i seguenti due elenchi di personaggi:

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

'G' in lb può essere copiato e posto davanti a 'd' a Los Angeles, per avere,

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

Sposta la nozione

'G' in lb può essere rimosso e posizionato davanti a 'd' a Los Angeles, per avere,

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

Valore nell'elemento

La copia e lo spostamento non sono così schietti come mostrato sopra. In una situazione reale, ogni valore (E.G., carattere) è in un elemento. Quindi, se un elenco di caratteri ha quattro caratteri, allora l'elenco ha quattro elementi. Se un elenco di caratteri ha tre caratteri, l'elenco ha tre elementi.

Un elemento può essere una struttura con 3 membri dei dati. Il primo membro dei dati è un puntatore che indica l'elemento precedente nell'elenco. Il secondo membro dei dati detiene il valore, in questo caso, il carattere. Il terzo membro dei dati è un puntatore che indica l'elemento successivo nell'elenco.

Quindi, ogni personaggio, come "G" sopra, sarebbe tenuto dal secondo membro dei dati di una struttura. Nel caso dell'elenco originale, LB sopra e per "G", il primo membro dei dati della struttura, indicherebbe l'elemento che ha "F", e il terzo membro dei dati della struttura indicherebbe l'elemento ha 'h'.

Inserisci ed EMPITANZA

Quando insert () deve copiare come espresso sopra, l'elemento di "g", i.e., La struttura completa, verrà copiata e collocata davanti all'elemento "D", in teoria. In pratica, dopo che un nuovo elemento corrispondente è considerato posizionato davanti all'elemento "D", verrà fatto il terzo membro dei dati della struttura del nuovo G per indicare l'elemento "D"; e il primo membro dei dati della nuova struttura del G verrà fatto indicare l'elemento "C" (dell'elenco LA).

Quando insert () deve muoversi come espresso sopra, la copia come spiegato qui viene fatto, allora l'elemento 'G' nell'elenco LB viene rimosso.

EMPLETTH (), d'altra parte, non deve davvero copiare o spostare alcun elemento. Deve solo essere indicato al programma che il valore di interesse è il personaggio, 'G'. Il programma costruirà quindi un nuovo elemento con "G" come valore davanti all'elemento "D" nell'elenco, la. Cioè, creerà una nuova struttura "G" davanti all'elemento "D", con il terzo membro dei dati che punta all'elemento "D" e al primo membro dei dati che punta all'elemento "C", come parte del procedura di costruzione.

Quindi, la differenza principale tra insert () ed emplace () è che EMPPLeat () costruisce l'elemento di inserimento sul punto, mentre insert () deve copiare o spostare l'elemento.

Questo articolo spiega cos'è la mappa-emplace e come utilizzare le due principali funzioni dei membri di EMPlace della mappa.

Contenuto dell'articolo

• L'elemento della mappa
• a_uniq.emplace (args)
• UN.emplace_hint (p, args)
• Conclusione

L'elemento della mappa

Di seguito sono riportati quattro nomi di frutta e i loro colori esterni:

banana => giallo
passione frutto => viola
Watermelon => Green
uva => rosa

Una mappa è costituita da coppie chiave/valore. In questo elenco ordinario, i nomi dei frutti sono le chiavi e i nomi dei colori esterni sono i valori. Tuttavia, questo è un elenco di coppie, non un elenco di valori da soli e non un elenco di tasti da soli. È un elenco di coppie chiave/valore. Le chiavi di una mappa sono uniche.

Nel codice, una chiave e il suo valore sono codificati come elemento, chiamato coppia. Ogni elemento sarebbe indicato da un iteratore. Quindi, un elemento della mappa vede una chiave come un valore e la chiave corrisponde a un altro valore. Quindi, un elemento della mappa necessita di due valori per creare un elemento; non uno come espresso nell'introduzione sopra. Questi due valori sono in qualche codice, chiamato coppia.

Il modello per l'elemento mappa è:

paio

Il primo parametro è per la chiave ed è indicato come key_type. Il secondo parametro è per il valore che corrisponde alla chiave. È indicato come mapp_type e non value_type. Value_Type è in realtà:

paio

il modello dell'elemento. Con l'array, gli indici sono ai valori. Con la mappa, gli iteratori sono alle coppie. Una coppia è un valore, che può essere detenuto dal secondo membro dei dati di una struttura e dal terzo membro dei dati che punta all'elemento successivo, che ha anche una coppia come valore; e il primo membro dei dati che punta all'elemento precedente, il cui valore è un'altra coppia.

Nell'elenco di frutta/colore sopra, la prima coppia può essere codificata come segue:

"banana", "giallo"

"Banana" è la chiave e "Yellow" è il valore, che forma una coppia chiave/valore. L'intera lista di due valori è un valore di valori_type e può essere mantenuta dal membro dei dati intermedi di un elemento struct. Il primo membro dei dati della struttura indicherà l'elemento precedente e il terzo membro dei dati della struttura indicherà l'elemento successivo.

Ora, una coppia è un oggetto la cui chiave ha prima il nome membro e il cui valore ha il nome del membro secondo.

Il seguente programma mette l'elenco sopra di frutti/colori in una mappa:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

carta geografica mp = "banana", "giallo", "passione frutto", "viola", "watermelon", "verde", "uva", "rosa";
per (mappa:: iterator IT = MP.inizio(); Esso != mp.FINE(); It ++)
cout << it->Primo << " => " << it->secondo << endl;
restituzione 0;

L'output è:

banana => giallo
passione frutto => viola
Watermelon => Green
uva => rosa

Si noti che la libreria delle mappe doveva essere inclusa.

Coppia eterogenea

Una coppia non deve necessariamente avere una chiave e un valore che abbia senso per l'utente ordinario. Può anche avere una chiave e un valore che non ha senso per l'utente ordinario ma ha senso per il programmatore. Come esempio per una coppia di tasti/valore che abbia senso per il programmatore, la chiave può essere un iteratore e il valore, un tipo di bool.

a_uniq.emplace (args)

Qui, a_uniq è il nome della mappa. Gli args sono la chiave e il valore per la coppia, separati da una virgola. La funzione membro restituisce una coppia, il cui primo valore è un iteratore (value_type); e il cui secondo valore è un bool, per indicare se l'inserimento (costruito sul posto) ha avuto successo (vero per il successo). L'iteratore restituito punta all'elemento inserito. La specifica C ++ non indica dove l'inserimento dovrebbe avvenire all'interno dell'elenco (o davanti o dietro) per questa funzione. Il seguente programma illustra l'uso della funzione:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

carta geografica mp = "banana", "giallo", "passione frutto", "viola", "watermelon", "verde", "uva", "rosa";
paio:: iterator, bool> pr = mp.EMPlace ("Strawberry", "Red");
cout << (pr.first)->Primo << " => " << (pr.first)->secondo << " : " << pr.second << endl;
cout << endl;
per (mappa:: iterator IT = MP.inizio(); Esso != mp.FINE(); It ++)
cout << it->Primo << " => " << it->secondo << endl;
restituzione 0;

L'output è:

fragola => rosso: 1
fragola => rosso
banana => giallo
passione frutto => viola
Watermelon => Green
uva => rosa

1 nella prima linea di output significa vero. Nota come gli args sono stati codificati come ("fragola", "rosso"). Non confondere tra valori_type e mappato _type.

UN.emplace_hint (p, args)

Qui, 'A' è il nome della mappa. Questa funzione membro è simile a quanto sopra, ma è suggerita la posizione in cui è necessario l'impianto nell'elenco delle mappe. È un iteratore, P che punta all'elemento prima e vicino al quale verrà posizionato l'inserimento (collocazione), in memoria. La funzione restituisce un iteratore e non una coppia. L'iteratore punta all'elemento appena inserito (coppia). Il seguente programma illustra questo:

#includere
#includere
Utilizzo dello spazio dei nomi std;
int main ()

carta geografica mp = "banana", "giallo", "passione frutto", "viola", "watermelon", "verde", "uva", "rosa";
carta geografica:: iterator p = mp.FINE();
P--;
carta geografica:: iterator iter = mp.emplace_hint (p, "fragola", "rosso");
cout << iter->Primo << " => " << iter->secondo << endl;
cout << endl;
per (mappa:: iterator IT = MP.inizio(); Esso != mp.FINE(); It ++)
cout << it->Primo << " => " << it->secondo << endl;
restituzione 0;

L'output è:

fragola => rosso
fragola => rosso
banana => giallo
passione frutto => viola
Watermelon => Green
uva => rosa

Conclusione

EmPlace and Insert sono simili. EmPlace costruisce il suo elemento sul punto nell'elenco, dopo aver ottenuto il valore, in qualche modo. D'altra parte, inserire copia il suo elemento nell'elenco da qualche parte o sposta l'elemento nell'elenco da qualche parte.

Nota: una mappa viene normalmente creata ordinata per chiavi. Per raggiungere questo obiettivo per la mappa sopra, utilizzare gli oggetti stringa per i tasti anziché i pointer costante-to-chars.