Clasa și obiecte
O clasă este un set de variabile și funcții care funcționează împreună, unde variabilele nu au valori atribuite. Când valorile sunt atribuite variabilelor, clasa devine un obiect. Valori diferite date aceleiași clase rezultă în obiecte diferite; adică diferite obiecte sunt aceeași clasă cu valori diferite. Se spune că crearea unui obiect dintr-o clasă este instanțierea obiectului.
Numele, unordered_map, este o clasă. Un obiect creat din clasa unordered_map are un nume ales de programator.
O funcție care aparține unei clase este necesară pentru a crea un obiect din clasă. În C ++, acea funcție are același nume ca și numele clasei. Obiectele create (instanțiate) din clasă au nume diferite date de către programator.
Crearea unui obiect din clasă înseamnă construirea obiectului; înseamnă și instanțierea.
Un program C ++ care utilizează clasa unordered_map, începe cu următoarele linii în partea de sus a fișierului:
#include#include
folosind spațiul de nume std;
Prima linie este pentru intrare / ieșire. A doua linie este de a permite programului să utilizeze toate caracteristicile clasei unordered_map. A treia linie permite programului să utilizeze numele din spațiul de nume standard.
Supraîncărcarea unei funcții
Când două sau mai multe semnături de funcții diferite au același nume, se spune că acel nume este suprasolicitat. Când se apelează o funcție, numărul și tipul argumentelor, determinați ce funcție este efectiv executată.
Construcție / Construire copiere
Construcție simplă
O hartă neordonată poate fi construită și atribuite valori după cum urmează:
harta_nordonată<const char*, const char*>umap;umap['banană'] = 'galben';
umap[„struguri”] = 'verde';
umap['Fig'] = 'Violet';
Declarația începe cu specializarea șablon cu tipurile pentru perechile cheie și valoare. Acesta este urmat de numele ales de programator pentru hartă; apoi un punct și virgulă. Al doilea segment de cod arată cum să atribuiți valorile cheilor lor.
Construcție după Initializer_list
Acest lucru se poate face după cum urmează:
{„struguri”, 'verde'}, {'Fig', 'Violet'}});
Construcție prin atribuirea Initializer_list
Exemplu:
{„struguri”, 'verde'}, {'Fig', 'Violet'}};
Construcție copiind o altă hartă unordered_map
Exemplu:
{„struguri”, 'verde'}, {'Fig', 'Violet'}});
harta_nordonată<const char*, const char*>umap2(umap1);
Perechea Element
Următorul cod arată cum să creați și să accesați elementul pereche:
pereche<char, const char*>relatii cu publicul= {'d', 'fi'};cost<<relatii cu publicul.primul << ' n';
cost<<relatii cu publicul.al doilea << ' n';
Ieșirea este:
dfi
primul și al doilea sunt cuvinte rezervate pentru cele două elemente din pereche. Valorile din pereche pot fi în continuare modificate folosind prima și a doua.
O pereche este numită, value_type în subiectul hărții neordonate.
unordered_map Acces element
mapped_type & operator [] (key_type && k)
Returnează valoarea pentru cheia corespunzătoare. Exemplu:
umap['banană'] = 'galben';
umap[„struguri”] = 'verde';
umap['Fig'] = 'Violet';
const char *dreapta=umap[„struguri”];
cost<<dreapta<<' n';
Ieșirea este: verde. Valorile pot fi atribuite în același mod - vezi mai sus.
unordered_map Capacitate
size_type size () const noexcept
Returnează numărul de perechi din hartă.
umap['banană'] = 'galben';
umap[„struguri”] = 'verde';
umap['Fig'] = 'Violet';
cost<<umap.mărimea() <<' n';
Ieșirea este 3.
bool empty () const noexcept
Returnează 1 pentru adevărat dacă harta nu are perechi și 0 pentru fals dacă are perechi. Exemplu:
harta_nordonată<const char*, const char*>umap;cost<<umap.gol() <<' n';
Ieșirea este 1.
Iteratorii care se întorc și clasa neordonată a hărții
Un iterator este ca un indicator, dar are mai multe funcționalități decât indicatorul.
begin () noexcept
Returnează un iterator care indică prima pereche a obiectului hartă, ca în următorul segment de cod:
harta_nordonată<const char*, const char*>umap;umap['banană'] = 'galben';umap[„struguri”] = 'verde';umap['Fig'] = 'Violet';
harta_nordonată<const char*, const char*> ::iteratoriter=umap.începe();
pereche<const char*, const char*>relatii cu publicul= *iter;
cost<<relatii cu publicul.primul << ',' <<relatii cu publicul.al doilea << ' n';
Ieșirea este: smochin, violet. Harta este neordonată.
begin () const noexcept;
Returnează un iterator care indică primul element al colecției de obiecte hartă. Când construcția obiectului este precedată de const, expresia begin () const este executată în loc de begin (). În această condiție, elementele din obiect nu pot fi modificate. Este folosit, de exemplu, în următorul cod.
constharta_nordonată<const char*, const char*>umap({{'banană', 'galben'},{„struguri”, 'verde'}, {'Fig', 'Violet'}});
harta_nordonată<const char*, const char*> ::const_iteratoriter=umap.începe();
pereche<const char*, const char*>relatii cu publicul= *iter;
cost<<relatii cu publicul.primul << ',' <<relatii cu publicul.al doilea << ' n';
Ieșirea este: smochin, violet. Harta este neordonată. Rețineți că const_iterator a fost folosit de această dată, în loc de doar iterator, pentru a primi iteratorul returnat.
end () noexcept
Returnează un iterator care indică imediat dincolo de ultimul element al obiectului hartă.
end () const noexcept
Returnează un iterator care indică imediat dincolo de ultimul element al obiectului hartă. Când construcția obiectului hartă este precedată de const, expresia end () const este executată în loc de end ().
unordered_map Operațiuni
găsirea iteratorului (const key_type & k)
Caută o pereche de chei date în hartă. Dacă este găsit, returnează iteratorul. Dacă nu este găsit, returnează un iterator care indică sfârșitul hărții, care nu este o pereche. Următorul cod arată cum să utilizați această funcție membru:
harta_nordonată<char,char>umap;umap['la'] = 'b';umap[„c”] = 'd';umap['Și'] = 'f';
harta_nordonată<char,char> ::iteratoriter=umap.găsi(„c”);
dacă (umap.găsi(„c”) ! =umap.Sfârșit())
{
pereche<char,char>relatii cu publicul= *iter;
cost<<relatii cu publicul.primul << ',' <<relatii cu publicul.al doilea << ' n';
}
Ieșirea este: c, d
const_iterator găsi (const key_type & k) const;
Această versiune a funcției se numește, dacă crearea hărții neordonate începe cu const, făcând toate elementele hărții numai în citire.
unordered_map Modificatori
inserție pereche (valoare_tip && obj)
O hartă neordonată înseamnă că perechile nu sunt în nici o ordine. Deci, programul introduce perechea în orice loc consideră convenabil. Funcția revine, pereche. Dacă inserarea a reușit, bool va fi 1 pentru adevărat, altfel ar fi 0 pentru fals. Dacă inserarea are succes, atunci iteratorul va indica elementul nou inserat. Următorul cod ilustrează utilizarea:
umap['banană'] = 'galben';
umap[„struguri”] = 'verde';
umap['Fig'] = 'Violet';
umap.introduce({{'cireașă', 'net'}, {'căpșună', 'net'}});
cost<<umap.mărimea() << ' n';
Rezultatul este: 5. Se pot introduce mai multe perechi.
size_type șterge (const key_type & k)
Această funcție șterge o pereche din unordered_map. Următorul segment de cod ilustrează:
harta_nordonată<const char*, const char*>umap;umap['banană'] = 'galben';
umap[„struguri”] = 'verde';
umap['Fig'] = 'Violet';
intpe unu=umap.şterge(„struguri”);
cost<<umap.mărimea() << ' n';
Ieșirea este 2.
swap nul (unordered_map &)
Două hărți neordonate pot fi schimbate, așa cum este ilustrat în acest segment de cod:
{„struguri”, 'verde'}, {'Fig', 'Violet'}, {'căpșună', 'net'}};
harta_nordonată<const char*, const char*>umap2= {{'cireașă', 'net'}, {'lămâie verde', 'verde'}};
umap1.swap(umap2);
harta_nordonată<const char*, const char*> ::iteratoriter1=umap1.începe();
pereche<const char*, const char*>pr1= *iter1;
harta_nordonată<const char*, const char*> ::iteratoriter2=umap2.începe();
pereche<const char*, const char*>pr2= *iter2;
cost<< „Prima cheie și dimensiunea umap1:”<<pr1.primul <<','<<umap1.mărimea() << ' n';
cost<< „Prima cheie și dimensiunea umap2”<<pr2.primul <<','<<umap2.mărimea() << ' n';
harta_nordonată<const char*, const char*>umap1= {{'banană', 'galben'},
{„struguri”, 'verde'}, {'Fig', 'Violet'}, {'căpșună', 'net'}};
harta_nordonată<const char*, const char*>umap2= {{'cireașă', 'net'}, {'lămâie verde', 'verde'}};
umap1.swap(umap2);
harta_nordonată<const char*, const char*> ::iteratoriter1=umap1.începe();
pereche<const char*, const char*>pr1= *iter1;
harta_nordonată<const char*, const char*> ::iteratoriter2=umap2.începe();
pereche<const char*, const char*>pr2= *iter2;
cost<< „Prima cheie și dimensiunea umap1:”<<pr1.primul <<','<<umap1.mărimea() << ' n';
cost<< „Prima cheie și dimensiunea umap2”<<pr2.primul <<','<<umap2.mărimea() << ' n';
Ieșirea este:
Prima cheie și dimensiunea umap1: var, 2
Prima cheie și dimensiunea căpșunii umap2, 4
Harta este neordonată. Rețineți că lungimea unei hărți este mărită, dacă este necesar. Tipurile de date trebuie să fie aceleași.
Class și obiectele sale instanțiate
O valoare este pentru un tip de date, așa cum un obiect instanțiat este pentru o clasă. Construcția hărții neordonate poate accepta, de asemenea, o clasă ca tip de date. Următorul program ilustrează acest lucru:
#include#include
folosind spațiul de nume std;
clasa TheCla
{
public:
intpe unu;
static charcap;
nulfunc(charNu, const char *str)
{
cost<< 'Sunt ' <<pe unu<< „cărți care merită” <<Nu<<str<< ' in magazin.' << ' n';
}
static nuldistracţie(charcap)
{
dacă (cap== 'la')
cost<< „Funcția oficială de membru static” << ' n';
}
};
intprincipal()
{
TheCla obj1;TheCla obj2;TheCla obj3;TheCla obj4;TheCla obj5;
harta_nordonată<const char*,TheCla>umap;
umap= {{'banană',obj1}, {„struguri”,obj2}, {'Fig',obj3}, {'căpșună',obj4}, {'lămâie verde',obj5}};
cost<<umap.mărimea() << ' n';
întoarcere 0;
}
Ieșirea este: 5.
Definiția clasei are două date publice și două funcții publice. În funcția main (), sunt instanțiate diferite obiecte pentru clasă. Apoi este instanțiată o hartă neordonată, în care fiecare pereche constă din numele unui fruct și a unui obiect din clasă. Se afișează dimensiunea hărții. Programul se compilează fără avertisment sau mesaj de eroare.
Aplicarea Hărții
Matricea asociază un index la valoare. Perechile cheie / valoare există în multe situații din viață, care pot fi programate. Perechea cheie / valoare fruct / culoare este doar un exemplu. Un alt exemplu este numele oamenilor și vârstele lor. În acest caz, perechea va fi de un tip, pereche. Poate fi și pereche. În acest din urmă caz, se va utiliza directiva de pre-procesare. O pereche cheie / valoare poate fi în continuare numele cuplurilor căsătorite. În țările în care există poligamie, vor exista diferite soții pentru un singur bărbat.
Formarea unei hărți
O hartă nu este o matrice bidimensională, cu două coloane. O hartă funcționează cu o funcție hash. Cheia este codificată de funcția hash, într-un număr întreg al unui tablou. Această matrice deține valorile. Deci, există de fapt o matrice cu valorile, iar cheile sunt mapate la indicii matricei, și astfel se fac corespondențele dintre chei și valori. Hashing este un subiect extins și nu este tratat în acest articol.
Concluzie
O hartă, cunoscută și sub numele de matrice asociativă, este o listă de elemente, în care fiecare element este o pereche cheie / valoare. Deci, fiecare cheie corespunde unei valori. În C ++, harta este implementată ca o structură de date cu funcții și operatori membri. O hartă ordonată este una în care perechile de elemente au fost ordonate prin taste. O hartă neordonată este una în care nu există comenzi.
Din punct de vedere tehnic, un hash este format din elemente de pereche. De fapt, perechea este o structură de date întreagă cu funcțiile și operatorii săi membri. Cei doi parametri șablon pentru pereche sunt aceiași doi parametri șablon pentru unordered_map.
Lista inițializatorului pentru hartă este o matrice literală a literelor. Fiecare literal intern este format din două obiecte, perechea cheie / valoare.
Funcțiile membre și operatorii pentru unordered_map pot fi clasificate în următoarele rubrici: unordered_map construction / copy construction, unordered_map Capacity, unordered_map iterator, unordered_map Operations și unordered_map Modifiers.
O hartă neordonată este utilizată atunci când o cheie trebuie mapată la o valoare.
Chrys