Come usare le mappe in C ++

La mappa C ++ è una struttura dei dati dell'elenco con coppie di tasti/valori. Una struttura di dati ha funzioni dei membri. In C ++, c'è una mappa e c'è un non ordinato_map. La mappa è in realtà una mappa ordinata. L'ordine per la mappa può essere ascendente o scendendo per chiavi. L'impostazione predefinita è l'ordine ascendente per chiavi. Le caratteristiche per la mappa ordinata e la mappa non ordinata sono così tante nella misura in cui solo quelle per la mappa (i.e., mappa ordinata) verrà considerata in questo articolo.

Le caratteristiche della mappa possono essere classificate in costruzione, accesso agli elementi, capacità, iteratori, modificatori, osservatori, operazioni e algoritmi specializzati. Succede anche che le caratteristiche della mappa siano molte. Quindi verranno spiegate solo le funzioni di base in queste categorie.

Un esempio di un elenco di coppie chiave/valore è il seguente elenco di frutti e i loro colori comuni della pelle maturi:

Blackberry => blu scuro-nero
mango => giallo
passione frutto => viola
plum => viola
banana => giallo

Le corde a sinistra dell'elenco formano le chiavi; quelli a destra formano i valori. Le coppie chiave/valore non devono necessariamente essere di stringa/stringa. Può essere di int/string, stringa/float, int/float, ecc. In una mappa C ++, una coppia chiave/valore è un elemento e tali elementi formano l'elenco della struttura dei dati. Una struttura dei dati della mappa fornisce un rapido recupero di dati in base alle chiavi. Le chiavi sono uniche e la struttura della mappa è molte a uno. Ciò significa che i valori possono avere duplicati, ma le chiavi non possono.

Per utilizzare la libreria delle mappe in un programma C ++, il programma dovrebbe iniziare con qualcosa come:

#includere
#includere
Utilizzo dello spazio dei nomi std;

Se le stringhe fanno parte della mappa, utilizzando #include anziché sarà consigliabile. Questo articolo spiega come utilizzare una mappa C ++.

Contenuto dell'articolo

• Costruzione/distruzione
• Costruire coppie e adattarsi
• Visualizzazione del contenuto della mappa (stampa)
• Accesso agli elementi
• Capacità
• Iteratori
• Modificatori
• Ordinazione ascendente o discendente
• Operazioni
• Algoritmi specializzati
• Conclusione

Costruzione/distruzione

Una mappa è un contenitore associativo che deve essere costruito da una classe di mappa.

Mappa (inizializer_list, const confront & = confront (), const allocatore & = allocatore ())

La seguente istruzione costruisce una mappa per l'elenco sopra per inizializzazione:

carta geografica mp "blackberry", "blu scuro-nero", "mango", "giallo", "passione frutto", "viola", "prugna", "viola" "banana" , "giallo";

Nota come ogni coppia è stata delimitata.

a = il

La seguente costruzione di inizializzazione, utilizza l'operatore di assegnazione:

carta geografica mp = "blackberry", "blu scuro-nero", "mango", "giallo", "passione frutto", "viola", "prugna", "viola" "banana ", "giallo";

Una mappa vuota può essere creata con l'espressione a sinistra, quindi gli elementi aggiunti in seguito - vedi sotto.

Distruzione
Per distruggere una mappa, lascialo andare fuori dalla portata.

Costruire coppie e adattarsi

Per la mappa sopra, una coppia è costituita da una chiave di stringa e un valore di stringa. Un elemento di coppia può essere costruito indipendentemente dalla mappa. Il seguente segmento di codice crea un oggetto coppia vuoto da una classe di coppia e quindi assegna un tasto e un valore:

Coppia PR;
Pr.Primo = "BlackBerry";
Pr.secondo = "blu scuro-nero";

Il nome per la proprietà chiave è il primo e il nome per la proprietà del valore è secondo. Il seguente codice crea una mappa vuota e inserisce due coppie utilizzando la funzione membro inserto mappa.

Mappa MP;
coppia pr0;
PR0.Primo = "BlackBerry";
PR0.secondo = "blu scuro-nero";
Coppia PR1;
PR1.Primo = "mango";
PR1.secondo = "giallo";
mp.inserire (PR0);
mp.inserire (PR1);

Visualizzazione del contenuto della mappa (stampa)

Il seguente codice utilizza un iteratore (IT), sviluppato dal primo elemento della mappa, per visualizzare le coppie chiave/valore, sulla console:

mappa mp = "plum", "viola", "mango", "giallo", "blackberry", "blu scuro-nero", "passione", "viola" " banana "," giallo ";
per (mappa :: iterator it = mp.inizio(); Esso!= mp.FINE(); ++ it)
cout Blackberry => blu scuro-nero
mango => giallo
passione frutto => viola
plum => viola

=> non ha significato C ++ qui. È solo usato per separare la chiave dal suo valore corrispondente al display. Per ottenere il valore di una proprietà di un puntatore (iteratore), utilizzare -> tra il puntatore (iteratore) e il nome della proprietà. Quindi, -> ha un significato in C++.

Si noti che l'elenco è stato visualizzato in ordine crescente delle chiavi, sebbene gli elementi non siano stati codificati.

È ancora possibile accedere alle coppie chiave/valore utilizzando lo schema per elementi-elementi. Il seguente segmento di codice illustra questo:

mappa mp = "plum", "viola", "mango", "giallo", "blackberry", "blu scuro-nero", "passione", "viola" " banana "," giallo ";
per (coppia Elem: MP)
cout << elem.first < " << elem.second < yellow
Blackberry => blu scuro-nero
mango => giallo
passione frutto => viola
plum => viola

Come prima. Si noti che Elem qui è un nome oggetto e non un puntatore (né iteratore). Quindi, è seguito da un punto e non -> per accedere alla proprietà.

Accesso agli elementi

T & Operator [] (key_type && x)

Un elemento non nella mappa prima può essere incluso utilizzando la sua chiave tramite [] operatore. Il valore di un elemento, che è già sulla mappa, può essere letto attraverso l'operatore [] utilizzando la sua chiave. Il seguente programma illustra questi:

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

Mappa MP;
mp ["plum"] = "viola";
mp ["passione frutto"] = "viola";
mp ["blackberry"] = "blu scuro-nero";
cout<cout<cout<restituzione 0;

L'output è:

viola
viola
Blu scuro-nero

const t & at (const key_type & x) const

Se la mappa viene dichiarata costante, allora i valori delle chiavi non possono essere modificati. Tuttavia, questa funzione membro può essere utilizzata per leggere i valori delle chiavi. Il seguente codice illustra questo:

const map mp "plum", "viola", "mango", "giallo", "blackberry", "blu scuro-nero";
cout<cout<cout<

L'output è:

viola
giallo
Blu scuro-nero

Capacità

size_type size () const noexcept

La lunghezza di una mappa può essere determinata utilizzando la funzione membro size (), come mostra il seguente codice:

const map mp "plum", "viola", "mango", "giallo", "blackberry", "blu scuro-nero";
cout<

L'output è 3.

[[nodiscard]] bool vuoto () const noexcept

Questa funzione membro restituisce vera se la mappa è vuota e falsa altrimenti. Esempio:

const map mp;
cout<

L'output è 1 per vero. Sarebbe stato 0 per false (altrimenti).

Iteratori

iteratore inizio () noxcept

Questo restituisce un iteratore bidirezionale che punta al primo elemento della mappa. Il valore dell'elemento (coppia) indica, può essere modificato. Codice di esempio:

mappa mp "plum", "viola", "mango", "giallo", "blackberry", "blu scuro-nero";
mappa :: iterator it;
per (it = mp.inizio(); Esso!= mp.FINE(); it ++)
cout
coutper (mappa :: iterator it = mp.inizio(); Esso!= mp.FINE(); it ++)
cout mango => giallo
plum => viola
Blackberry => blu scuro-nero
mango => bianco
plum => viola

Il valore per la seconda coppia di tasti/valore è stato modificato. Nota l'uso dell'iteratore terminale ().

reverse_iterator rbegin () noexcept

Ciò restituisce un iteratore inverso bidirezionale, indicando l'ultimo elemento della mappa. Il valore dell'elemento a cui punta può essere modificato. Il seguente codice produce lo stesso risultato di quanto sopra:

mappa mp "plum", "viola", "mango", "giallo", "blackberry", "blu scuro-nero";
mappa :: revers_iterator it;
per (it = mp.rbegin (); Esso!= mp.rend (); it ++)
cout
coutper (mappa :: revers_iterator it = mp.rbegin (); Esso!= mp.rend (); it ++)
cout mango => giallo
Blackberry => blu scuro-nero
plum => viola
mango => bianco
Blackberry => blu scuro-nero

Lo stesso valore per la seconda coppia di tasti/valore è stato modificato.

Modificatori

Con la mappa, poiché verrà sempre disposto (ordinato) tramite chiavi, dopo l'inserimento, non importa se l'inserimento è mirato dal programmatore all'inizio, all'interno o alla fine della mappa. L'ordine ascendente per chiavi è il risultato predefinito.

La modifica della mappa si occupa di inserire, spidare, estrarre, cancellare e compromettere. L'inserimento e l'emplacamento sono simili, ma l'emplacamento è migliore.

EMPIPACHI

paio a_uniq.emplace (args)

Questa funzione membro inserisce i letterali della coppia chiave/valore, separata da virgola, senza parentesi ricci, come mostrato nel seguente codice:

mappa mp = "blackberry", "blu scuro-nero", "mango", "giallo", "passione frutto", "viola";
paio pr = mp.EMPlace ("Banana", "Yellow");
per (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout<cout Blackberry => blu scuro-nero
mango => giallo
passione frutto => viola
banana => 1

La funzione membro EMPlace (Args) restituisce una coppia corrispondente all'elemento inserito. La chiave di questa coppia di ritorno è un iteratore che punta all'elemento inserito. Il valore di questa coppia di ritorno è vero (1) se l'inserimento ha avuto luogo e falso (0) se l'inserimento non ha avuto luogo.

Nota il modo in cui è stato codificato il tipo di ritorno per EMPlace (Args). Inoltre, la coppia di ritorno non è stata utilizzata per ottenere la chiave/valore della coppia di mappe inserita nell'ultima istruzione di output. Ci sono due tipi di coppie qui: la coppia per la mappa e la coppia di ritorno. Non sono compatibili. Se la chiave esisteva già nella mappa, l'iteratore restituito indicherebbe la chiave esistente; Quindi, il valore booleano sarebbe falso.

Inserimento

paio insert (value_type && x)

Questa funzione membro inserisce i letterali della coppia chiave/valore, separata da virgola, con le staffe ricci, come mostrato nel seguente codice:

mappa mp = "blackberry", "blu scuro-nero", "mango", "giallo", "passione frutto", "viola";
paio pr = mp.insert ("banana", "giallo");
per (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout<cout Blackberry => blu scuro-nero
mango => giallo
passione frutto => viola
banana => 1

La spiegazione è simile al caso sopra per EMPlace (Args).

paio Insert (const value_type & x)

L'identificatore di una coppia può essere usato come argomento per la funzione insert (). Illustrazione:

mappa mp = "blackberry", "blu scuro-nero", "mango", "giallo", "passione frutto", "viola";
Coppia PR;
Pr.Primo = "banana";
Pr.secondo = "giallo";
paio ib = mp.inserire (PR);
per (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout<cout Blackberry => blu scuro-nero
mango => giallo
passione frutto => viola
banana => 1

La spiegazione è simile al caso sopra.

void insert (inizializer_list)

È possibile inserire un intero elenco. Immediatamente dopo l'inserimento, c'è un riarrangiamento (in ordine crescente). Illustrazione:

mappa mp = "blackberry", "blu scuro-nero", "mango", "giallo", "passione frutto", "viola";
mp.Insert ("Watermelon", "Green", "Grape", "Pink", "Abricot", "Orange");
per (Auto Elem: MP)
cout << elem.first < " << elem.second < orange
Blackberry => blu scuro-nero
uva => rosa
mango => giallo
passione frutto => viola
Watermelon => Green

Nota: non dovrebbe esistere alcuna chiave dell'elenco sulla mappa.

Vuoto Insert (InputIterator First, InputIterator Last)

Un intervallo, [i, j) da un'altra mappa può essere inserito. Qui, io e J siamo iteratori. Illustrazione:

mappa mp1 = "uva", "rosa", "albicocca", "arancione", "fragola", "rosso", "pesca", "giallo scuro", "papaya", "arancia";
mappa :: iterator ITB = mp1.inizio();
ITB ++;
mappa :: iterator ite = mp1.FINE();
ite--; ite--;
mappa mp2 = "blackberry", "blu scuro-nero", "mango", "giallo", "passione frutto", "viola";
MP2.inserire (ITB, ite);
per (Auto Elem: MP2)
cout << elem.first < " << elem.second < dark blue-black
uva => rosa
mango => giallo
papaya => arancione
passione frutto => viola

Si noti che l'elemento corrispondente a J della prima mappa non è stato inserito. Questo è conforme alla notazione, [i, j).

Cancellare

size_type cancella (const key_type e x)

Cancella l'elemento identificato dalla chiave e restituisce il numero di elementi cancellati (dovrebbe essere 1 nel caso di non Multimap). Illustrazione:

mappa mp = "blackberry", "blu scuro-nero", "mango", "giallo", "passione frutto", "viola";
int n = mp.cancella ("mango");
cout<per (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout <cout<passione frutto => viola
2

L'elemento cancellato viene rimosso, per quanto riguarda l'utente. Quindi il numero di elementi è ridotto.

Iterator Erase (posizione const_iterator)

La cancellazione può essere eseguita usando un iteratore. Restituisce un iteratore che punta all'elemento dopo quello che viene cancellato. Illustrazione:

mappa mp = "blackberry", "blu scuro-nero", "mango", "giallo", "passione frutto", "viola";
mappa :: iterator it = mp.inizio();
It ++;
mappa :: iterator iter = mp.cancellalo);
cout per (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout <cout<Blackberry => blu scuro-nero
passione frutto => viola
2

Iterator Erase (const_iterator First, const_iterator Last)

Questo utilizza iteratori per cancellare un intervallo dalla mappa ordinata. Restituisce un iteratore che punta all'elemento dopo l'intervallo cancellato. Illustrazione:

mappa mp = "uva", "rosa", "albicocca", "arancione", "fragola", "rosso", "pesca", "giallo scuro", "papaya", "arancia";
per (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout <mappa :: iterator itb = mp.inizio();
ITB ++;
mappa :: iterator ite = mp.FINE();
ite--; ite--;
mappa :: iterator iter = mp.cancella (ITB, ite);
cout per (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout <cout<uva => rosa
papaya => arancione
pesca => giallo scuro
fragola => rosso
pesca => giallo scuro
albicocca => arancione
pesca => giallo scuro
fragola => rosso
3

L'ordinamento del contenuto originale della mappa viene visualizzato per la prima volta all'uscita in modo che l'intervallo cancellato possa essere apprezzato. Si noti che l'elemento indicato dal secondo argomento Iteratore non viene cancellato.

Chiaro

void Clear () noexcept

Cancella tutti gli elementi della mappa, facendo le dimensioni della mappa, zero. Esempio:

mappa mp = "uva", "rosa", "albicocca", "arancione", "fragola", "rosso";
mp.chiaro();
cout<

L'output è 0.

Estrazione
Questo si occupa di node_type - vedi più tardi.

Fusione
Quando si uniscono due mappe, gli elementi si mescolano in ordine (ascendente); Nessuna coppia chiave/valore è separata.

vuoto a.unire (A2)

Un elemento in A2 con la stessa chiave in A non viene estratto. Questo si occupa di node_type - vedi più tardi.

Ordinazione ascendente o discendente

Per impostazione predefinita, una mappa diventa ascendente dalle chiavi subito dopo la creazione. Può essere fatto discreto. Nelle parentesi angolari del modello, il terzo parametro ha il tipo predefinito, meno. E così, non deve essere digitato. Per far scendere la mappa per chiave, è necessario utilizzare una maggiore, come nel seguente codice:

carta geografica mp = "Grape", "Pink", "Apricot", "Orange", "Strawberry", "Red";
per (Auto Elem: MP)
cout << elem.first < " << elem.second < red
uva => rosa
albicocca => arancione

Non appena viene creata una mappa, viene ordinata ascendente o discendente (ascendente per impostazione predefinita). meno o più è noto come un oggetto di confronto.

Operazioni

Iterator Find (const key_type & x)

Restituisce l'iteratore dell'elemento la cui chiave è l'argomento da trovare (). Illustrazione:

carta geografica mp = "Grape", "Pink", "Apricot", "Orange", "Strawberry", "Red";
mappa :: iterator it = mp.trovare ("uva");
cout

Iterator Lower_Bound (const key_type e x)

In una mappa, gli elementi sono disposti per chiave, in ordine crescente, per impostazione predefinita. Se il programmatore vuole conoscere l'iteratore che indica l'elemento che non è inferiore a quello di una chiave particolare, deve usare questa funzione membro. Illustrazione:

mappa mp = "uva", "rosa", "albicocca", "arancione", "fragola", "rosso", "pesca", "giallo scuro", "papaya", "arancia";
per (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout <mappa :: iterator it = mp.Lower_bound ("Papaya");
cout uva => rosa
papaya => arancione
pesca => giallo scuro
fragola => rosso
papaya => arancione

In questa situazione, l'iteratore indica l'elemento chiave. Se la chiave non viene trovata, la funzione restituirà un iteratore che punti subito dopo la fine della mappa. In questa situazione, è ciclico e sarebbe il primo elemento della mappa.

Iterator Upper_Bound (const key_type e x)

Se il programmatore vuole conoscere l'iteratore che indica l'elemento con una chiave maggiore di K, deve utilizzare questa funzione membro. Illustrazione:

mappa mp = "uva", "rosa", "albicocca", "arancione", "fragola", "rosso", "pesca", "giallo scuro", "papaya", "arancia";
per (Auto Elem: MP)
cout << elem.first < " << elem.second << endl;
cout <mappa :: iterator it = mp.Upper_bound ("Papaya");
cout uva => rosa
papaya => arancione
pesca => giallo scuro
fragola => rosso
pesca => giallo scuro

Un iteratore che punta all'elemento subito dopo che l'elemento chiave è stato restituito. Se la chiave è per l'ultimo elemento, dovrebbe essere lanciata un'eccezione. Se la chiave non esiste, il risultato è inaffidabile.

Algoritmi specializzati

Quanto segue è la sintassi di una funzione di algoritmo specializzato:

modello
void swap (map & x, map & y) noexcept (noexcept (x.Swap (y)));

È possibile utilizzare invece la seguente sintassi:

vuoto scambio (mappa e)

Questo scambia le coppie delle due mappe, che non devono essere della stessa dimensione. Esempio:

mappa mp1 = "plum", "viola", "mango", "giallo", "blackberry", "blu scuro-nero", "passione frutto", "viola", " banana "," giallo ";
mappa mp2 = "Watermelon", "Green", "Grape", "Pink", "Abricot", "Orange", "Strawberry", "Red", "Peach", "," giallo scuro ", " papaya "," arancione ";
mp1.swap (MP2);
cout << "New mp1:" << endl;
per (Auto Elem: MP1)
cout << elem.first < " << elem.second << endl;
cout<cout << "New mp2:" << endl;
per (Auto Elem: MP2)
cout << elem.first < " << elem.second << endl;

Conclusione

Una mappa è costituita da coppie chiave/valore. È ordinato da tasti, ascendente o discendente. L'ordine predefinito è salita. Funzioni dei membri di base per la mappa: mappa (), operatore [], at (), dimensione (), vuoto (), inizio (), end (), rbegin (), rend (), emplace (), insert () , cancella (), clear (), find (), lower_bound (), Upper_bound () e A1Swap (A2).