Hur man använder C ++ Oordnad karta

How Use C Unordered Map



En karta, även känd som en associativ matris, är en lista över element, där varje element är ett nyckel/värdepar. Så varje nyckel motsvarar ett värde. Olika nycklar kan ha samma värde för vanligt arbete. Till exempel kan nycklarna vara en lista över frukter och motsvarande värden, färgerna på frukterna. I C ++ implementeras kartan som en datastruktur med medlemsfunktioner och operatörer. En ordnad karta är en där elementpar har ordnats med nycklar. En orörd karta är en karta där det inte finns någon ordning. Den här artikeln förklarar hur du använder C ++ oordnad karta, skriven som unordered_map. Du behöver kunskap i C ++ - pekare för att förstå den här artikeln. unordered_map är en del av standardbiblioteket C ++.

Klass och objekt

En klass är en uppsättning variabler och funktioner som fungerar tillsammans, där variablerna inte har värden tilldelade. När värden tilldelas variablerna blir klassen ett objekt. Olika värden som ges till samma klass resulterar i olika objekt; det vill säga olika objekt är samma klass med olika värden. Att skapa ett objekt från en klass sägs vara att instantiera objektet.







Namnet, unordered_map, är en klass. Ett objekt som skapats från klassen unordered_map har ett programmerat namn.



En funktion som tillhör en klass behövs för att instantiera ett objekt från klassen. I C ++ har den funktionen samma namn som klassens namn. Objekt som skapats (instanserats) från klassen har olika namn som programmeraren har gett dem.



Att skapa ett objekt från klassen innebär att konstruera objektet; det betyder också att instiniera.





Ett C ++ - program som använder klassen unordered_map, börjar med följande rader högst upp i filen:

#omfatta
#omfatta
med namnutrymme std;

Den första raden är för input/output. Den andra raden är att låta programmet använda alla funktioner i klassen unordered_map. Den tredje raden gör att programmet kan använda namnen i standardnamnutrymmet.



Överbelastning av en funktion

När två eller flera olika funktionssignaturer har samma namn sägs det namnet vara överbelastat. När en funktion anropas bestämmer antalet och typen av argument vilken funktion som faktiskt utförs.

Konstruktion/kopiering

Enkel konstruktion

En orörd karta kan konstrueras och tilldelas värden enligt följande:

oordnad_karta<konst röding*, konst röding*>umap;

umap['banan'] = 'gul';
umap['druva'] = 'grön';
umap['fikon'] = 'lila';

Deklarationen börjar med mallspecialiseringen med typerna för nyckel- och värdepar. Detta följs av programmerarens valda namn för kartan; sedan ett semikolon. Det andra kodsegmentet visar hur man tilldelar sina nycklar värden.
Konstruktion av Initializer_list
Detta kan göras enligt följande:

oordnad_karta<konst röding*, konst röding*>umap({{'banan', 'gul'},
{'druva', 'grön'}, {'fikon', 'lila'}});

Konstruktion genom att tilldela Initializer_list
Exempel:

oordnad_karta<konst röding*, konst röding*>umap= {{'banan', 'gul'},
{'druva', 'grön'}, {'fikon', 'lila'}};

Konstruktion genom att kopiera en annan oordnad_karta
Exempel:

oordnad_karta<konst röding*, konst röding*>umap1({{'banan', 'gul'},
{'druva', 'grön'}, {'fikon', 'lila'}});
oordnad_karta<konst röding*, konst röding*>umap2(umap1);

Paret Element

Följande kod visar hur du skapar och får åtkomst till parelementet:

par<röding, konst röding*>pr= {'d', 'vara'};
kosta<<pr.först << ' n';
kosta<<pr.andra << ' n';

Utgången är:

d
vara

första och andra är reserverade ord för de två objekten i paret. Värdena i paret kan fortfarande ändras med första och andra.

Ett par kallas, value_type i ämnet för den oordnade kartan.

unordered_map Element Access

mapped_type & operator [] (key_type && k)
Returnerar värdet för motsvarande nyckel. Exempel:

oordnad_karta<konst röding*, konst röding*>umap;

umap['banan'] = 'gul';
umap['druva'] = 'grön';
umap['fikon'] = 'lila';

konst röding *höger=umap['druva'];

kosta<<höger<<' n';

Utgången är: grön. Värden kan tilldelas på samma sätt - se ovan.

unordered_map Kapacitet

size_type size () const noexcept
Returnerar antalet par på kartan.

oordnad_karta<konst röding*, konst röding*>umap;

umap['banan'] = 'gul';
umap['druva'] = 'grön';
umap['fikon'] = 'lila';

kosta<<umap.storlek() <<' n';

Utgången är 3.

bool tom () const noexcept

Returnerar 1 för true om kartan inte har något par och 0 för falskt om den har par. Exempel:

oordnad_karta<konst röding*, konst röding*>umap;
kosta<<umap.tömma() <<' n';

Utgången är 1.

Återkommande Iteratorer och den oordnade kartklassen

En iterator är som en pekare men har mer funktionalitet än pekaren.

begin () noexcept

Returnerar en iterator som pekar på det första paret i kartobjektet, som i följande kodsegment:

oordnad_karta<konst röding*, konst röding*>umap;

umap['banan'] = 'gul';umap['druva'] = 'grön';umap['fikon'] = 'lila';

oordnad_karta<konst röding*, konst röding*> ::iteratoriter=umap.Börja();
par<konst röding*, konst röding*>pr= *iter;
kosta<<pr.först << ',' <<pr.andra << ' n';

Utgången är: fig, lila. Kartan är obeställd.

begin () const noexcept;

Returnerar en iterator som pekar på det första elementet i kartobjektsamlingen. När objektkonstruktionen föregås av const, körs uttrycket begin () const istället för begin (). Under detta villkor kan elementen i objektet inte ändras. Det används till exempel i följande kod.

konstoordnad_karta<konst röding*, konst röding*>umap({{'banan', 'gul'},
{'druva', 'grön'}, {'fikon', 'lila'}});

oordnad_karta<konst röding*, konst röding*> ::const_iteratoriter=umap.Börja();
par<konst röding*, konst röding*>pr= *iter;
kosta<<pr.först << ',' <<pr.andra << ' n';

Utgången är: fig, lila. Kartan är obeställd. Observera att const_iterator har använts denna gång, istället för bara iterator, för att ta emot den returnerade iteratorn.

slutet () någotxcept

Returnerar en iterator som pekar omedelbart bortom det sista elementet i kartobjektet.

slut () const noexcept

Returnerar en iterator som pekar omedelbart bortom det sista elementet i kartobjektet. När kartobjektkonstruktionen föregås av const, körs uttrycket end () const istället för end ().

unordered_map -operationer

iterator hitta (const key_type & k)

Söker efter ett par av den angivna nyckeln på kartan. Om den hittas returnerar den iteratorn. Om den inte hittas returnerar den en iterator som pekar på kartans ände, vilket inte är ett par. Följande kod visar hur du använder denna medlemsfunktion:

oordnad_karta<röding,röding>umap;

umap['till'] = 'b';umap['c'] = 'd';umap['Och'] = 'f';

oordnad_karta<röding,röding> ::iteratoriter=umap.hitta('c');
om (umap.hitta('c') ! =umap.slutet())
{
par<röding,röding>pr= *iter;
kosta<<pr.först << ',' <<pr.andra << ' n';
}

Utgången är: c, d

const_iterator hitta (const key_type & k) const;

Denna version av funktionen kallas, om skapandet av den oordnade kartan börjar med const, vilket gör alla element i kartan skrivskyddade.

unordered_map Modifiers

parinsats (value_type && obj)
En orörd karta betyder att paren inte är i någon ordning. Så, programmet sätter in paret på valfri plats det passar. Funktionen returnerar, par. Om insättningen lyckades kommer bool att vara 1 för true, annars skulle det vara 0 för falskt. Om insättningen lyckas kommer iteratorn att peka på det nyinsatta elementet. Följande kod illustrerar användningen:

oordnad_karta<konst röding*, konst röding*>umap;

umap['banan'] = 'gul';
umap['druva'] = 'grön';
umap['fikon'] = 'lila';

umap.Föra in({{'körsbär', 'netto'}, {'jordgubbe', 'netto'}});

kosta<<umap.storlek() << ' n';

Utgången är: 5. Mer än ett par kan sättas in.

storlek_typ radera (const key_type & k)

Denna funktion raderar ett par från den unordered_map. Följande kodsegment illustrerar:

oordnad_karta<konst röding*, konst röding*>umap;

umap['banan'] = 'gul';
umap['druva'] = 'grön';
umap['fikon'] = 'lila';

intpå ett=umap.radera('druva');

kosta<<umap.storlek() << ' n';

Utgången är 2.
void swap (unordered_map &)
Två oordnade kartor kan bytas, som illustreras i detta kodsegment:

oordnad_karta<konst röding*, konst röding*>umap1= {{'banan', 'gul'},
{'druva', 'grön'}, {'fikon', 'lila'}, {'jordgubbe', 'netto'}};

oordnad_karta<konst röding*, konst röding*>umap2= {{'körsbär', 'netto'}, {'kalk', 'grön'}};

umap1.byta(umap2);

oordnad_karta<konst röding*, konst röding*> ::iteratoriter1=umap1.Börja();
par<konst röding*, konst röding*>pr1= *iter1;
oordnad_karta<konst röding*, konst röding*> ::iteratoriter2=umap2.Börja();
par<konst röding*, konst röding*>pr2= *iter2;

kosta<< 'Första nyckeln och storleken på umap1:'<<pr1.först <<','<<umap1.storlek() << ' n';
kosta<< 'Första nyckeln och storleken på umap2'<<pr2.först <<','<<umap2.storlek() << ' n';
oordnad_karta<konst röding*, konst röding*>umap1= {{'banan', 'gul'},
{'druva', 'grön'}, {'fikon', 'lila'}, {'jordgubbe', 'netto'}};
oordnad_karta<konst röding*, konst röding*>umap2= {{'körsbär', 'netto'}, {'kalk', 'grön'}};

umap1.byta(umap2);

oordnad_karta<konst röding*, konst röding*> ::iteratoriter1=umap1.Börja();
par<konst röding*, konst röding*>pr1= *iter1;
oordnad_karta<konst röding*, konst röding*> ::iteratoriter2=umap2.Börja();
par<konst röding*, konst röding*>pr2= *iter2;

kosta<< 'Första nyckeln och storleken på umap1:'<<pr1.först <<','<<umap1.storlek() << ' n';
kosta<< 'Första nyckeln och storleken på umap2'<<pr2.först <<','<<umap2.storlek() << ' n';

Utgången är:

Första nyckeln och storleken på umap1: lime, 2

Första nyckeln och storleken på umap2 jordgubbe, 4

Kartan är obeställd. Observera att längden på en karta ökar vid behov. Datatyperna måste vara desamma.

Class och dess Instantiated Objects

Ett värde är en datatyp, som ett instanserat objekt är för en klass. Den oordnade kartkonstruktionen kan också acceptera en klass som datatyp. Följande program illustrerar detta:

#omfatta
#omfatta
med namnutrymme std;

klass TheCla
{
offentlig:
intpå ett;
statisk rödingkap;

tomhetfungera(rödingNej, konst röding *sid)
{
kosta<< 'Det finns ' <<på ett<< 'värda böcker' <<Nej<<sid<< ' i affären.' << ' n';
}
statisk tomhetroligt(rödingkap)
{
om (kap== 'till')
kosta<< 'Officiell statisk medlemsfunktion' << ' n';
}
};

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

oordnad_karta<konst röding*,TheCla>umap;
umap= {{'banan',obj1}, {'druva',obj2}, {'fikon',obj3}, {'jordgubbe',obj4}, {'kalk',obj5}};

kosta<<umap.storlek() << ' n';

lämna tillbaka 0;
}

Utgången är: 5.

Klassdefinitionen har två data offentliga medlemmar och två offentliga medlemsfunktioner. I huvudfunktionen () instansieras olika objekt för klassen. En orörd karta instansieras sedan, där varje par består av namnet på en frukt och ett objekt från klassen. Kartans storlek visas. Programmet kompileras utan varning eller felmeddelande.

Kartans tillämpning

Arrayen kopplar ett index till värde. Nyckel/värdepar finns i många situationer i livet, som kan programmeras. Nyckel-/värdeparet frukt/färg är bara ett exempel. Ett annat exempel är namnet på människor och deras åldrar. I det här fallet kommer paret att vara av en typ, par. Det kan också vara par. I det senare fallet kommer förbehandlingsdirektivet att användas. Ett nyckel-/värdepar kan fortfarande vara namnen på gifta par. I länder där det finns polygami kommer det att finnas olika fruar för en man.

Bildande av en karta

En karta är inte en tvådimensionell matris, med två kolumner. En karta fungerar med en hash -funktion. Nyckeln kodas av hash -funktionen till ett heltal i en array. Det är denna matris som håller värdena. Så det finns faktiskt en array med värdena, och nycklar mappas till arrayens index, och så görs överensstämmelserna mellan nycklar och värden. Hashing är ett omfattande ämne och omfattas inte av den här artikeln.

Slutsats

En karta, även känd som en associativ matris, är en lista över element, där varje element är ett nyckel/värdepar. Så varje nyckel motsvarar ett värde. I C ++ implementeras kartan som en datastruktur med medlemsfunktioner och operatörer. En ordnad karta är en där elementpar har ordnats med nycklar. En orörd karta är en karta där det inte finns någon beställning.

Tekniskt sett består en hash av parelement. I själva verket är paret en hel datastruktur med dess medlemsfunktioner och operatörer. De två mallparametrarna för paret är samma två mallparametrar för den unordered_map.

Initializer_list för kartan är en matris bokstavlig av bokstavar. Varje intern bokstav består av två objekt, nyckel/värdeparet.

Medlemsfunktionerna och operatörerna för orörd_karta kan kategoriseras under följande rubriker: orörd_kartkonstruktion/kopieringskonstruktion, orörd_karta -kapacitet, orörd_karta -iterator, orörd_karta -operationer och orörd_karta -modifierare.

En orörd karta används när en nyckel måste mappas till ett värde.

Chrys