Come utilizzare la mappa non ordinata C ++

Una mappa, nota anche come array associativo è un elenco di elementi, in cui ogni elemento è una coppia chiave/valore. Quindi, ogni chiave corrisponde a un valore. Tasti diversi possono avere lo stesso valore, per il lavoro ordinario. Ad esempio, le chiavi possono essere un elenco di frutti e valori corrispondenti, i colori dei frutti. In C ++, la mappa è implementata come struttura di dati con funzioni e operatori membri. Una mappa ordinata è quella in cui le coppie di elementi sono state ordinate da tasti. Una mappa non ordinata è quella in cui non esiste un ordine. Questo articolo spiega come utilizzare la mappa non ordinata C ++, scritta come non ordinato_map. Hai bisogno di conoscenza nei puntatori C ++ per comprendere questo articolo. UNORDERD_MAP fa parte della libreria standard C ++.

Classe e oggetti

Una classe è un insieme di variabili e funzioni che funzionano insieme, in cui le variabili non hanno valori assegnati. Quando i valori vengono assegnati alle variabili, la classe diventa un oggetto. Valori diversi dati alla stessa classe derivano in oggetti diversi; cioè, oggetti diversi sono la stessa classe con valori diversi. Si dice che la creazione di un oggetto da una classe stia istanziando l'oggetto.

Il nome, non ordinato_map, è una classe. Un oggetto creato dalla classe UNORDERD_MAP ha un nome programmatore scelto.

È necessaria una funzione che appartiene a una classe per istanziare un oggetto dalla classe. In C ++, quella funzione ha lo stesso nome del nome della classe. Gli oggetti creati (istanziati) dalla classe hanno nomi diversi dati, dal programmatore.

Creazione di un oggetto dalla classe significa costruire l'oggetto; Significa anche istanziamento.

Un programma C ++ che utilizza la classe UNORDED_MAP, inizia con le seguenti righe nella parte superiore del file:

#includere
#includere
Utilizzo dello spazio dei nomi std;

La prima riga è per input/output. La seconda riga è consentire al programma di utilizzare tutte le funzionalità della classe UNORDED_MAP. La terza riga consente al programma di utilizzare i nomi nello spazio dei nomi standard.

Sovraccaricare una funzione

Quando due o più firme della funzione diverse hanno lo stesso nome, si dice che quel nome sia sovraccarico. Quando viene chiamata una funzione, il numero e il tipo di argomenti, determinare quale funzione viene effettivamente eseguita.

Costruzione/Copia Costruzione

Costruzione semplice

Una mappa non ordinata può essere costruita e assegnata i valori come segue:

UNORDERD_MAP Umap;
Umap ["Banana"] = "Yellow";
Umap ["Grape"] = "Green";
Umap ["Fig"] = "Purple";

La dichiarazione inizia con la specializzazione del modello con i tipi per le coppie di tasti e valori. Questo è seguito dal nome scelto dal programmatore per la mappa; Quindi un punto e virgola. Il secondo segmento di codice mostra come assegnare i valori alle loro chiavi.
Costruzione di Initializer_List
Questo può essere fatto come segue:

UNORDERD_MAP Umap ("Banana", "Yellow",
"Grape", "Green", "Fig", "Purple");

Costruzione assegnando inizialezer_list
Esempio:

UNORDERD_MAP Umap = "Banana", "Yellow",
"Grape", "Green", "Fig", "Purple";

Costruzione copiando un altro non ordinato_map
Esempio:

UNORDERD_MAP Umap1 ("Banana", "Yellow",
"Grape", "Green", "Fig", "Purple");
UNORDERD_MAP Umap2 (UMAP1);

L'elemento coppia

Il seguente codice mostra come creare e accedere all'elemento coppia:

paio pr = 'd', "Sea";
cout << pr.first << '\n';
cout << pr.second << '\n';

L'output è:

D
mare

Il primo e il secondo sono parole riservate per i due elementi nella coppia. I valori nella coppia possono ancora essere modificati usando il primo e il secondo.

Viene chiamata una coppia, valori_type nell'argomento della mappa non ordinata.

Accesso agli elementi UNORDORDED_MAP

mapped_type & operator [] (key_type && k)
Restituisce il valore per la chiave corrispondente. Esempio:

UNORDERD_MAP Umap;
Umap ["Banana"] = "Yellow";
Umap ["Grape"] = "Green";
Umap ["Fig"] = "Purple";
const char *ret = umap ["uva"];
cout << ret <<'\n';

L'output è: "verde". I valori possono essere assegnati allo stesso modo - vedi sopra.

Capacità UNORDORDED_MAP

size_type size () const noexcept
Restituisce il numero di coppie nella mappa.

UNORDERD_MAP Umap;
Umap ["Banana"] = "Yellow";
Umap ["Grape"] = "Green";
Umap ["Fig"] = "Purple";
cout << umap.size() <<'\n';

L'output è 3.

bool vuoto () const noexcept

Restituisce 1 per vero se la mappa non ha coppie e 0 per false se ha coppie. Esempio:

UNORDERD_MAP Umap;
cout << umap.empty() <<'\n';

L'output è 1.

Restituire iteratori e la classe non ordinata

Un iteratore è come un puntatore ma ha più funzionalità del puntatore.

Inizia () noAxcept

Restituisce un iteratore che punta alla prima coppia dell'oggetto MAP, come nel seguente segmento di codice:

UNORDERD_MAP Umap;
Umap ["Banana"] = "Yellow"; Umap ["Grape"] = "Green"; Umap ["Fig"] = "Purple";
UNORDERD_MAP:: iterator iter = Umap.inizio();
paio pr = *iter;
cout << pr.first << ", " << pr.second << '\n';

L'output è: fig, viola. La mappa non è ordinata.

inizio () const noexcept;

Restituisce un iteratore che indica il primo elemento della raccolta degli oggetti della mappa. Quando la costruzione dell'oggetto viene preceduta da const, l'espressione "inizio () const" viene eseguita invece di "inizio ()". In questa condizione, gli elementi nell'oggetto non possono essere modificati. Viene utilizzato nel seguente codice, ad esempio.

const non ordined_map Umap ("Banana", "Yellow",
"Grape", "Green", "Fig", "Purple");
UNORDERD_MAP:: const_iterator iter = uMap.inizio();
paio pr = *iter;
cout << pr.first << ", " << pr.second << '\n';

L'output è: fig, viola. La mappa non è ordinata. Si noti che questa volta è stato usato const_iterator, anziché solo iteratore, per ricevere l'iteratore restituito.

end () noexcept

Restituisce un iteratore che indica immediatamente oltre l'ultimo elemento dell'oggetto mappa.

end () const noexcept

Restituisce un iteratore che indica immediatamente oltre l'ultimo elemento dell'oggetto mappa. Quando la costruzione dell'oggetto MAP è preceduta da const, l'espressione "end () const" viene eseguita al posto di "end ()".

Operazioni UNORDERD_MAP

Iterator Find (const key_type & k)

Cerca una coppia della chiave indicata nella mappa. Se viene trovato, restituisce l'iteratore. Se non trovato, restituisce un iteratore che punta alla fine della mappa, che non è una coppia. Il seguente codice mostra come utilizzare questa funzione membro:

UNORDERD_MAP Umap;
Umap ['a'] = 'b'; Umap ['c'] = 'd'; Umap ['e'] = 'f';
UNORDERD_MAP:: iterator iter = Umap.trovare ('c');
if (uMap.Trova ('C') != Umap.FINE())
paio pr = *iter;
cout << pr.first << ", " << pr.second << '\n';

L'output è: c, d

const_iterator find (const key_type & k) const;

Questa versione della funzione viene chiamata se la creazione della mappa non ordinata inizia con const, rendendo tutti gli elementi della mappa.

Modificatori non ordinati_map

coppia insert (value_type && obj)
Una mappa non ordinata significa che le coppie non sono in nessun ordine. Quindi, il programma inserisce la coppia in qualsiasi luogo che trova conveniente. La funzione ritorna, coppia. Se l'inserimento avesse successo, Bool sarà 1 per vero, altrimenti sarebbe 0 per false. Se l'inserimento ha esito positivo, allora l'iteratore indicherà l'elemento appena inserito. Il seguente codice illustra l'uso:

UNORDERD_MAP Umap;
Umap ["Banana"] = "Yellow";
Umap ["Grape"] = "Green";
Umap ["Fig"] = "Purple";
Umap.insert ("Cherry", "rosso", "fragola", "rosso");
cout << umap.size() << '\n';

L'output è: 5. Più di una coppia può essere inserita.

size_type cancella (const key_type & k)

Questa funzione cancella una coppia da non orderd_map. Il seguente segmento di codice illustra:

UNORDERD_MAP Umap;
Umap ["Banana"] = "Yellow";
Umap ["Grape"] = "Green";
Umap ["Fig"] = "Purple";
int num = umap.cancellare ("uva");
cout << umap.size() << '\n';

L'output è 2.
vuoto scambio (non ordined_map &)
È possibile scambiare due mappe non ordinate, come illustrato in questo segmento di codice:

UNORDERD_MAP Umap1 = "Banana", "Yellow",
"Grape", "Green", "Fig", "Purple", "Strawberry", "Red";
UNORDERD_MAP Umap2 = "Cherry", "rosso", "lime", "verde";
Umap1.Swap (Umap2);
UNORDERD_MAP:: iterator iter1 = Umap1.inizio();
paio pr1 = *iter1;
UNORDERD_MAP:: iterator iter2 = Umap2.inizio();
paio pr2 = *iter2;
cout << "First key and size of umap1: "<< pr1.first <<", "<< umap1.size() << '\n';
cout << "First key and size of umap2 "<< pr2.first <<", "<< umap2.size() << '\n';
UNORDERD_MAP Umap1 = "Banana", "Yellow",
"Grape", "Green", "Fig", "Purple", "Strawberry", "Red";
UNORDERD_MAP Umap2 = "Cherry", "rosso", "lime", "verde";
Umap1.Swap (Umap2);
UNORDERD_MAP:: iterator iter1 = Umap1.inizio();
paio pr1 = *iter1;
UNORDERD_MAP:: iterator iter2 = Umap2.inizio();
paio pr2 = *iter2;
cout << "First key and size of umap1: "<< pr1.first <<", "<< umap1.size() << '\n';
cout << "First key and size of umap2 "<< pr2.first <<", "<< umap2.size() << '\n';

L'output è:

Prima chiave e dimensione di UMAP1: lime, 2
Prima chiave e dimensione di Umap2 Strawberry, 4

La mappa non è ordinata. Si noti che la lunghezza di una mappa è aumentata se necessario. I tipi di dati devono essere gli stessi.

Classe e i suoi oggetti istanziati

Un valore è per un tipo di dati, poiché un oggetto istanziato è per una classe. La costruzione della mappa non ordinata può anche accettare una classe come tipo di dati. Il seguente programma illustra questo:

#includere
#includere
Utilizzo dello spazio dei nomi std;
class thecla
pubblico:
int num;
Statico Char Ch;
void func (char cha, const char *str)
cout << "There are " << num << " books worth " << cha << str << " in the store." << '\n';

statico void fun (char ch)
if (ch == 'a')
cout << "Official static member function" << '\n';

;
int main ()

Thecla obj1; Thecla obj2; Thecla obj3; Thecla obj4; Thecla obj5;
UNORDERD_MAP Umap;
Umap = "Banana", obj1, "uva", obj2, "fig", obj3, "fragola", obj4, "lime", obj5;
cout << umap.size() << '\n';
restituzione 0;

L'output è: 5.

La definizione della classe ha due membri pubblici di dati e due funzioni dei membri pubblici. Nella funzione principale (), sono istanziati oggetti diversi per la classe. Viene quindi istanziata una mappa non ordinata, in cui ogni coppia è costituita dal nome di un frutto e di un oggetto della classe. Viene visualizzata la dimensione della mappa. Il programma si compila senza avviso o messaggio di errore.

Applicazione della mappa

L'array associa un indice da valutare. Le coppie chiave/valori esistono in molte situazioni nella vita, che possono essere programmate. La coppia chiave/valore di frutta/colore è solo un esempio. Un altro esempio è il nome delle persone e delle loro età. In questo caso, la coppia sarà di tipo, coppia. Può anche essere una coppia. In quest'ultimo caso, verrà impiegata la direttiva di pre-elaborazione. Una coppia chiave/valore può ancora essere i nomi delle coppie sposate. Nei paesi in cui c'è poligamia, ci saranno diverse mogli per un uomo.

Formazione di una mappa

Una mappa non è un array bidimensionale, con due colonne. Una mappa funziona con una funzione hash. La chiave è codificata dalla funzione hash, in un numero intero di un array. È questo array che contiene i valori. Quindi, in realtà c'è un array con i valori e le chiavi vengono mappate sugli indici dell'array, e quindi vengono fatte le corrispondenze tra chiavi e valori. L'hashing è un argomento ampio e non è trattato in questo articolo.

Conclusione

Una mappa, nota anche come array associativo è un elenco di elementi, in cui ogni elemento è una coppia chiave/valore. Quindi, ogni chiave corrisponde a un valore. In C ++, la mappa è implementata come struttura di dati con funzioni e operatori membri. Una mappa ordinata è quella in cui le coppie di elementi sono state ordinate da tasti. Una mappa non ordinata è quella in cui non c'è ordine.

Tecnicamente, un hash è costituito da elementi di coppia. In effetti, la coppia è un'intera struttura di dati con le funzioni e gli operatori dei suoi membri. I due parametri del modello per la coppia sono gli stessi due parametri del modello per UNOrdined_Map.

Initializer_list per la mappa è un array letterale dei letterali. Ogni letterale interno è costituito da due oggetti, la coppia chiave/valore.

Le funzioni e gli operatori del membro per UnOrdered_Map possono essere classificati sotto le seguenti titoli: UNORDERD_MAP COSTRUZIONE/COPIA COSTRUZIONE, CAPASIONE UNORDED_MAP, UNORDED_MAP Iterator, Operazioni UNORDORDED_MAP e modificatori non OrderD_MAP.

Una mappa non ordinata viene utilizzata quando una chiave deve essere mappata su un valore.