Sådan bruges C ++ Uordnet kort

How Use C Unordered Map



Et kort, også kendt som et associativt array, er en liste over elementer, hvor hvert element er et nøgle/værdipar. Så hver nøgle svarer til en værdi. Forskellige nøgler kan have samme værdi for almindeligt arbejde. For eksempel kan nøglerne være en liste over frugter og de tilsvarende værdier, frugternes farver. I C ++ implementeres kortet som en datastruktur med medlemsfunktioner og operatører. Et ordnet kort er et, hvor elementparrene er blevet ordnet med nøgler. Et uordnet kort er et, hvor der ikke er nogen ordre. Denne artikel forklarer, hvordan du bruger C ++ uordnet kort, skrevet som uordnet_kort. Du har brug for viden i C ++ - pointers for at forstå denne artikel. unordered_map er en del af C ++ - standardbiblioteket.

Klasse og genstande

En klasse er et sæt variabler og funktioner, der fungerer sammen, hvor variablerne ikke har værdier tildelt. Når værdierne tildeles variablerne, bliver klassen et objekt. Forskellige værdier givet til den samme klasse resulterer i forskellige objekter; det vil sige, at forskellige objekter er den samme klasse med forskellige værdier. At oprette et objekt fra en klasse siges at være instantiating objektet.







Navnet, unordered_map, er en klasse. Et objekt, der er oprettet fra klassen unordered_map, har et programmeret navn.



En funktion, der tilhører en klasse, er nødvendig for at instantiere et objekt fra klassen. I C ++ har denne funktion det samme navn som navnet på klassen. Objekter, der er oprettet (instantieret) fra klassen, har givet forskellige navne af programmereren.



At skabe et objekt fra klassen betyder at konstruere objektet; det betyder også instantiating.





Et C ++ - program, der bruger klassen unordered_map, starter med følgende linjer øverst i filen:

#omfatte
#omfatte
ved hjælp af navneområde std;

Den første linje er for input/output. Den anden linje er at tillade programmet at bruge alle funktionerne i klassen unordered_map. Den tredje linje gør det muligt for programmet at bruge navnene i standardnavneområdet.



Overbelastning af en funktion

Når to eller flere forskellige funktionssignaturer har samme navn, siges det navn at være overbelastet. Når en funktion kaldes, bestemmer antallet og typen af ​​argumenter, hvilken funktion der faktisk udføres.

Konstruktion/kopi konstruktion

Enkel konstruktion

Et uordnet kort kan konstrueres og tildeles værdier som følger:

uordnet_kort<konst forkælelse*, konst forkælelse*>umap;

umap['banan'] = 'gul';
umap['drue'] = 'grøn';
umap['fig'] = 'lilla';

Erklæringen begynder med skabelonspecialiseringen med typerne for nøgle- og værdipar. Dette efterfølges af programmørens valgte navn til kortet; derefter et semikolon. Det andet kodesegment viser, hvordan man tildeler værdier til deres nøgler.
Konstruktion efter Initializer_list
Dette kan gøres som følger:

uordnet_kort<konst forkælelse*, konst forkælelse*>umap({{'banan', 'gul'},
{'drue', 'grøn'}, {'fig', 'lilla'}});

Konstruktion ved at tildele Initializer_list
Eksempel:

uordnet_kort<konst forkælelse*, konst forkælelse*>umap= {{'banan', 'gul'},
{'drue', 'grøn'}, {'fig', 'lilla'}};

Konstruktion ved at kopiere endnu et uordnet_kort
Eksempel:

uordnet_kort<konst forkælelse*, konst forkælelse*>umap1({{'banan', 'gul'},
{'drue', 'grøn'}, {'fig', 'lilla'}});
uordnet_kort<konst forkælelse*, konst forkælelse*>umap2(umap1);

Par -elementet

Følgende kode viser, hvordan du opretter og får adgang til parelementet:

par<forkælelse, konst forkælelse*>pr= {'d', 'være'};
koste<<pr.først << ' n';
koste<<pr.sekund << ' n';

Outputtet er:

d
være

første og andet er reserverede ord for de to elementer i parret. Værdierne i parret kan stadig ændres ved hjælp af første og anden.

Et par kaldes, value_type i emnet for det uordnede kort.

unordered_map Element Access

mapped_type & operator [] (key_type && k)
Returnerer værdien for den tilsvarende nøgle. Eksempel:

uordnet_kort<konst forkælelse*, konst forkælelse*>umap;

umap['banan'] = 'gul';
umap['drue'] = 'grøn';
umap['fig'] = 'lilla';

konst forkælelse *ret=umap['drue'];

koste<<ret<<' n';

Outputtet er: grønt. Værdier kan tildeles på samme måde - se ovenfor.

unordered_map Kapacitet

size_type size () const noexcept
Returnerer antallet af par på kortet.

uordnet_kort<konst forkælelse*, konst forkælelse*>umap;

umap['banan'] = 'gul';
umap['drue'] = 'grøn';
umap['fig'] = 'lilla';

koste<<umap.størrelse() <<' n';

Output er 3.

bool tom () const noexcept

Returnerer 1 for true, hvis kortet ikke har et par, og 0 for false, hvis det har par. Eksempel:

uordnet_kort<konst forkælelse*, konst forkælelse*>umap;
koste<<umap.tom() <<' n';

Output er 1.

Tilbagevendende Iteratorer og klasse uden ordnet kort

En iterator er som en markør, men har mere funktionalitet end markøren.

begynde () noexcept

Returnerer en iterator, der peger på det første par af kortobjektet, som i følgende kodesegment:

uordnet_kort<konst forkælelse*, konst forkælelse*>umap;

umap['banan'] = 'gul';umap['drue'] = 'grøn';umap['fig'] = 'lilla';

uordnet_kort<konst forkælelse*, konst forkælelse*> ::iteratoriter=umap.begynde();
par<konst forkælelse*, konst forkælelse*>pr= *iter;
koste<<pr.først << ',' <<pr.sekund << ' n';

Outputtet er: fig, lilla. Kortet er ubestilt.

begin () const noexcept;

Returnerer en iterator, der peger på det første element i kortobjektsamlingen. Når objektkonstruktionen går forud for const, udføres udtrykket begin () const i stedet for begin (). Under denne betingelse kan elementerne i objektet ikke ændres. Det bruges f.eks. I følgende kode.

konstuordnet_kort<konst forkælelse*, konst forkælelse*>umap({{'banan', 'gul'},
{'drue', 'grøn'}, {'fig', 'lilla'}});

uordnet_kort<konst forkælelse*, konst forkælelse*> ::const_iteratoriter=umap.begynde();
par<konst forkælelse*, konst forkælelse*>pr= *iter;
koste<<pr.først << ',' <<pr.sekund << ' n';

Outputtet er: fig, lilla. Kortet er ubestilt. Bemærk, at const_iterator denne gang er blevet brugt i stedet for kun iterator til at modtage den returnerede iterator.

ende () noget undtagen

Returnerer en iterator, der peger umiddelbart ud over det sidste element i kortobjektet.

ende () const noexcept

Returnerer en iterator, der peger umiddelbart ud over det sidste element i kortobjektet. Når kortobjektkonstruktionen går forud for const, udføres udtrykket end () const i stedet for end ().

unordered_map -operationer

iterator find (const key_type & k)

Søger efter et par af den givne nøgle på kortet. Hvis den findes, returnerer den iteratoren. Hvis den ikke findes, returnerer den en iterator, der peger mod enden af ​​kortet, som ikke er et par. Følgende kode viser, hvordan du bruger denne medlemsfunktion:

uordnet_kort<forkælelse,forkælelse>umap;

umap['til'] = 'b';umap['c'] = 'd';umap['Og'] = 'f';

uordnet_kort<forkælelse,forkælelse> ::iteratoriter=umap.Find('c');
hvis (umap.Find('c') ! =umap.ende())
{
par<forkælelse,forkælelse>pr= *iter;
koste<<pr.først << ',' <<pr.sekund << ' n';
}

Outputtet er: c, d

const_iterator find (const key_type & k) const;

Denne version af funktionen kaldes, hvis oprettelsen af ​​det uordnede kort begynder med const, hvilket gør alle kortets elementer skrivebeskyttet.

unordered_map Modifikatorer

par indsæt (value_type && obj)
Et uordnet kort betyder, at parrene ikke er i nogen rækkefølge. Så programmet indsætter parret ethvert sted, det finder praktisk. Funktionen vender tilbage, par. Hvis indsættelsen lykkedes, vil bool være 1 for sand, ellers ville det være 0 for falsk. Hvis indsættelsen er vellykket, vil iteratoren pege på det nyligt indsatte element. Følgende kode illustrerer brugen:

uordnet_kort<konst forkælelse*, konst forkælelse*>umap;

umap['banan'] = 'gul';
umap['drue'] = 'grøn';
umap['fig'] = 'lilla';

umap.indsæt({{'kirsebær', 'net'}, {'jordbær', 'net'}});

koste<<umap.størrelse() << ' n';

Outputtet er: 5. Der kan indsættes mere end et par.

størrelse_type slet (const key_type & k)

Denne funktion sletter et par fra det uordnede_kort. Følgende kodesegment illustrerer:

uordnet_kort<konst forkælelse*, konst forkælelse*>umap;

umap['banan'] = 'gul';
umap['drue'] = 'grøn';
umap['fig'] = 'lilla';

intpå en=umap.slette('drue');

koste<<umap.størrelse() << ' n';

Output er 2.
ugyldig swap (uordnet_kort &)
To uordnede kort kan byttes, som illustreret i dette kodesegment:

uordnet_kort<konst forkælelse*, konst forkælelse*>umap1= {{'banan', 'gul'},
{'drue', 'grøn'}, {'fig', 'lilla'}, {'jordbær', 'net'}};

uordnet_kort<konst forkælelse*, konst forkælelse*>umap2= {{'kirsebær', 'net'}, {'Citron', 'grøn'}};

umap1.bytte rundt(umap2);

uordnet_kort<konst forkælelse*, konst forkælelse*> ::iteratoriter1=umap1.begynde();
par<konst forkælelse*, konst forkælelse*>pr1= *iter1;
uordnet_kort<konst forkælelse*, konst forkælelse*> ::iteratoriter2=umap2.begynde();
par<konst forkælelse*, konst forkælelse*>pr2= *iter2;

koste<< 'Første nøgle og størrelse på umap1:'<<pr1.først <<','<<umap1.størrelse() << ' n';
koste<< 'Første nøgle og størrelse på umap2'<<pr2.først <<','<<umap2.størrelse() << ' n';
uordnet_kort<konst forkælelse*, konst forkælelse*>umap1= {{'banan', 'gul'},
{'drue', 'grøn'}, {'fig', 'lilla'}, {'jordbær', 'net'}};
uordnet_kort<konst forkælelse*, konst forkælelse*>umap2= {{'kirsebær', 'net'}, {'Citron', 'grøn'}};

umap1.bytte rundt(umap2);

uordnet_kort<konst forkælelse*, konst forkælelse*> ::iteratoriter1=umap1.begynde();
par<konst forkælelse*, konst forkælelse*>pr1= *iter1;
uordnet_kort<konst forkælelse*, konst forkælelse*> ::iteratoriter2=umap2.begynde();
par<konst forkælelse*, konst forkælelse*>pr2= *iter2;

koste<< 'Første nøgle og størrelse på umap1:'<<pr1.først <<','<<umap1.størrelse() << ' n';
koste<< 'Første nøgle og størrelse på umap2'<<pr2.først <<','<<umap2.størrelse() << ' n';

Outputtet er:

Første nøgle og størrelse på umap1: lime, 2

Første nøgle og størrelse på umap2 jordbær, 4

Kortet er ubestilt. Bemærk, at længden af ​​et kort øges, hvis det er nødvendigt. Datatyperne skal være de samme.

Klasse og dens Instantiated Objects

En værdi er til en datatype, som et instantieret objekt er for en klasse. Den uordnede kortkonstruktion kan også acceptere en klasse som datatype. Følgende program illustrerer dette:

#omfatte
#omfatte
ved hjælp af navneområde std;

klasse TheCla
{
offentlig:
intpå en;
statisk forkælelsekap;

ugyldigfungere(forkælelseingen, konst forkælelse *s)
{
koste<< 'Der er ' <<på en<< 'bøger værd' <<ingen<<s<< ' i butikken.' << ' n';
}
statisk ugyldigsjovt(forkælelsekap)
{
hvis (kap== 'til')
koste<< 'Officiel statisk medlemsfunktion' << ' n';
}
};

intvigtigste()
{
TheCla obj1;TheCla obj2;TheCla obj3;TheCla obj4;TheCla obj5;

uordnet_kort<konst forkælelse*,TheCla>umap;
umap= {{'banan',obj1}, {'drue',obj2}, {'fig',obj3}, {'jordbær',obj4}, {'Citron',obj5}};

koste<<umap.størrelse() << ' n';

Vend tilbage 0;
}

Outputtet er: 5.

Klassedefinitionen har to data offentlige medlemmer og to offentlige medlemsfunktioner. I hovedfunktionen () instantieres forskellige objekter for klassen. Et uordnet kort instantieres derefter, hvor hvert par består af navnet på en frugt og et objekt fra klassen. Kortets størrelse vises. Programmet kompileres uden advarsel eller fejlmeddelelse.

Anvendelse af kortet

Arrayen knytter et indeks til værdi. Nøgle/værdipar findes i mange situationer i livet, som kan programmeres. Nøgle/værdiparret frugt/farve er blot et eksempel. Et andet eksempel er navnet på mennesker og deres alder. I dette tilfælde vil parret være af en type, par. Det kan også være par. I sidstnævnte tilfælde vil direktivet om forbehandling blive anvendt. Et nøgle/værdipar kan stadig være navne på ægtepar. I lande, hvor der er polygami, vil der være forskellige koner til en mand.

Dannelse af et kort

Et kort er ikke et todimensionalt array med to kolonner. Et kort fungerer med en hash -funktion. Nøglen er kodet af hashfunktionen til et helt tal i en matrix. Det er denne matrix, der holder værdierne. Så der er faktisk et array med værdierne, og nøglerne er tilknyttet matrixens indeks, og derfor foretages korrespondancerne mellem nøgler og værdier. Hashing er et omfattende emne og er ikke dækket i denne artikel.

Konklusion

Et kort, også kendt som et associativt array, er en liste over elementer, hvor hvert element er et nøgle/værdipar. Så hver nøgle svarer til en værdi. I C ++ implementeres kortet som en datastruktur med medlemsfunktioner og operatører. Et ordnet kort er et, hvor elementparrene er blevet ordnet med nøgler. Et uordnet kort er et, hvor der ikke er bestilt.

Teknisk set består en hash af parelementer. Faktisk er parret en hel datastruktur med sine medlemsfunktioner og operatører. De to skabelonparametre for parret er de samme to skabelonparametre for det uordnede_kort.

Initializer_list for kortet er en matrix literal af literals. Hver intern bogstavelig består af to objekter, nøgle/værdiparet.

Medlemsfunktionerne og operatørerne for uordnet_kort kan kategoriseres under følgende overskrifter: uordnet_kort konstruktion/kopi konstruktion, uordnet_kort kapacitet, uordnet_kort iterator, uordnet_kort operationer og uordnet_kort modifikatorer.

Et uordnet kort bruges, når en nøgle skal kortlægges til en værdi.

Chrys