Klase at Mga Bagay
Ang isang klase ay isang hanay ng mga variable at pagpapaandar na gumagana nang magkasama, kung saan ang mga variable ay walang mga itinalagang halaga. Kapag ang mga halaga ay itinalaga sa mga variable, ang klase ay magiging isang object. Ang iba't ibang mga halagang ibinigay sa parehong klase ay nagreresulta sa iba't ibang mga bagay; iyon ay, iba't ibang mga bagay ay ang parehong klase na may iba't ibang mga halaga. Ang paglikha ng isang bagay mula sa isang klase ay sinasabing nagpapatibay ng bagay.
Ang pangalan, unordered_map, ay isang klase. Ang isang bagay na nilikha mula sa unordered_map class ay may isang napiling programmer na pangalan.
Ang isang pagpapaandar na kabilang sa isang klase ay kinakailangan upang masimulan ang isang bagay mula sa klase. Sa C ++, ang pagpapaandar na iyon ay may parehong pangalan sa pangalan ng klase. Ang mga bagay na nilikha (instantiated) mula sa klase ay may iba't ibang mga pangalan na ibinigay sa kanila, ng programmer.
Ang paglikha ng isang bagay mula sa klase ay nangangahulugang pagbuo ng object; nangangahulugan din ito ng pag-uudyok.
Ang isang C ++ na programa na gumagamit ng unordered_map class, nagsisimula sa mga sumusunod na linya sa tuktok ng file:
# isama# isama
gamit ang namespace std;
Ang unang linya ay para sa input / output. Ang pangalawang linya ay upang payagan ang programa na gamitin ang lahat ng mga tampok ng unordered_map na klase. Pinapayagan ng pangatlong linya ang programa na gamitin ang mga pangalan sa karaniwang namespace.
Pag-overload ng isang Pag-andar
Kapag ang dalawa o higit pang magkakaibang mga lagda ng pag-andar ay may parehong pangalan, ang pangalan na iyon ay sinasabing sobra ang karga. Kapag ang isang pagpapaandar ay tinawag, ang bilang at uri ng mga argumento, alamin kung aling pagpapaandar ang aktwal na naisagawa.
Konstruksiyon / Pagbuo ng Kopya
Simpleng Konstruksiyon
Ang isang hindi naayos na mapa ay maaaring itayo at italaga ang mga halagang tulad ng sumusunod:
unordered_map<Const char*, Const char*>umap;umap['saging'] = 'dilaw';
umap['ubas'] = 'berde';
umap['fig'] = 'lila';
Nagsisimula ang deklarasyon sa pagdadalubhasa ng template sa mga uri para sa mga pares ng susi at halaga. Sinusundan ito ng napiling pangalan ng programmer para sa mapa; pagkatapos ng isang semicolon. Ipinapakita ng segment ng pangalawang code kung paano magtalaga ng mga halaga sa kanilang mga key.
Konstruksiyon ng Initializer_list
Maaari itong gawin tulad ng sumusunod:
{'ubas', 'berde'}, {'fig', 'lila'}});
Konstruksiyon sa pamamagitan ng pagtatalaga ng Initializer_list
Halimbawa:
{'ubas', 'berde'}, {'fig', 'lila'}};
Konstruksiyon sa pamamagitan ng pagkopya ng isa pang hindi naayos na_map
Halimbawa:
{'ubas', 'berde'}, {'fig', 'lila'}});
unordered_map<Const char*, Const char*>umap2(umap1);
Ang pares na Elemento
Ipinapakita ng sumusunod na code kung paano lumikha at mag-access sa elemento ng pares:
pares<char, Const char*>pr= {'d', 'maging'};gastos<<pr.una << ' n';
gastos<<pr.pangalawa << ' n';
Ang output ay:
dmaging
una at pangalawa ay nakalaan ang mga salita para sa dalawang item sa pares. Ang mga halaga sa pares ay maaari pa ring mabago gamit ang una at pangalawa.
Ang isang pares ay tinawag, value_type sa paksa ng hindi naayos na mapa.
unordered_map Element Access
na-map_type at operator [] (key_type && k)
Ibinabalik ang halaga para sa kaukulang key. Halimbawa:
umap['saging'] = 'dilaw';
umap['ubas'] = 'berde';
umap['fig'] = 'lila';
Const char *tama=umap['ubas'];
gastos<<tama<<' n';
Ang output ay: berde. Ang mga halaga ay maaaring italaga sa parehong paraan - tingnan sa itaas.
unordered_map na Kapasidad
size_type size () const noexcept
Ibinabalik ang bilang ng mga pares sa mapa.
umap['saging'] = 'dilaw';
umap['ubas'] = 'berde';
umap['fig'] = 'lila';
gastos<<umaplaki() <<' n';
Ang output ay 3.
walang laman ang () const noexcept
Ibinabalik ang 1 para sa totoo kung ang mapa ay walang pares, at 0 para sa hindi totoo kung mayroon itong mga pares. Halimbawa:
unordered_map<Const char*, Const char*>umap;gastos<<umapwalang laman() <<' n';
Ang output ay 1.
Bumabalik na Iterators at ang hindi naayos na-mapa ng Klase
Ang isang iterator ay tulad ng isang pointer ngunit may higit na pag-andar kaysa sa pointer.
magsimula () walang eksep
Nagbabalik ng isang umuulit na tumuturo sa unang pares ng object ng mapa, tulad ng sa sumusunod na segment ng code:
unordered_map<Const char*, Const char*>umap;umap['saging'] = 'dilaw';umap['ubas'] = 'berde';umap['fig'] = 'lila';
unordered_map<Const char*, Const char*> ::paulit-ulititer=umapmagsimula();
pares<Const char*, Const char*>pr= *iter;
gastos<<pr.una << ',' <<pr.pangalawa << ' n';
Ang output ay: igos, lila. Ang mapa ay hindi naka-order.
simulan () const noexcept;
Nagbabalik ng isang umuulit na tumuturo sa unang elemento ng koleksyon ng object ng mapa. Kapag ang pagbuo ng bagay ay naunahan ng const, ang expression na magsisimula () ay naisakatuparan sa halip na magsimula (). Sa ilalim ng kondisyong ito, ang mga elemento sa bagay ay hindi maaaring mabago. Ginagamit ito sa sumusunod na code, halimbawa.
Constunordered_map<Const char*, Const char*>umap({{'saging', 'dilaw'},{'ubas', 'berde'}, {'fig', 'lila'}});
unordered_map<Const char*, Const char*> ::Const_iteratoriter=umapmagsimula();
pares<Const char*, Const char*>pr= *iter;
gastos<<pr.una << ',' <<pr.pangalawa << ' n';
Ang output ay: igos, lila. Ang mapa ay hindi naka-order. Tandaan na ang Const_iterator ay ginamit sa oras na ito, sa halip na iterator lamang, upang matanggap ang naibalik na iterator.
magtapos () walang eksep
Nagbabalik ng isang umuulit na tumuturo kaagad na lampas sa huling elemento ng bagay ng mapa.
pagtatapos () const noexcept
Nagbabalik ng isang umuulit na tumuturo kaagad na lampas sa huling elemento ng bagay ng mapa. Kapag ang pagbuo ng bagay ng mapa ay naunahan ng const, ang expression na end () const ay naisagawa sa halip na wakasan ().
unordered_map na Mga Operasyon
iterator find (const key_type & k)
Naghahanap ng isang pares ng ibinigay na key sa mapa. Kung ito ay natagpuan, ibabalik nito ang iterator. Kung hindi nahanap, nagbabalik ito ng isang iterator na tumuturo sa dulo ng mapa, na hindi isang pares. Ipinapakita ng sumusunod na code kung paano gamitin ang pagpapaandar ng miyembro na ito:
unordered_map<char,char>umap;umap['to'] = 'b';umap['c'] = 'd';umap['At'] = 'f';
unordered_map<char,char> ::paulit-ulititer=umaphanapin('c');
kung (umaphanapin('c') ! =umapmagtapos())
{
pares<char,char>pr= *iter;
gastos<<pr.una << ',' <<pr.pangalawa << ' n';
}
Ang output ay: c, d
Const_iterator find (const key_type & k) const;
Ang bersyon ng pagpapaandar na ito ay tinatawag na, kung ang paglikha ng hindi nakaayos na mapa ay nagsisimula sa const, ginagawa ang lahat ng mga elemento ng mapa na nabasa lamang.
unordered_map Mga Modifier
ipasok ang pares (value_type && obj)
Ang isang hindi nakaayos na mapa ay nangangahulugang ang mga pares ay wala sa anumang pagkakasunud-sunod. Kaya, pinapasok ng programa ang pares sa anumang lugar na nakikita nitong maginhawa. Ang pagpapaandar ay nagbabalik, ipares. Kung matagumpay ang pagpapasok, ang bool ay magiging 1 para sa totoo, kung hindi man ay 0 para sa hindi totoo. Kung ang pagpasok ay matagumpay, kung gayon ang iterator ay magtuturo sa bagong ipinasok na elemento. Ang sumusunod na code ay naglalarawan ng paggamit:
umap['saging'] = 'dilaw';
umap['ubas'] = 'berde';
umap['fig'] = 'lila';
umapipasok({{'seresa', 'net'}, {'strawberry', 'net'}});
gastos<<umaplaki() << ' n';
Ang output ay: 5. Mahigit sa isang pares ang maaaring ipasok.
size_type burahin (const key_type & k)
Ang pagpapaandar na ito ay nagbubura ng isang pares mula sa unordered_map. Ang sumusunod na segment ng code ay naglalarawan:
unordered_map<Const char*, Const char*>umap;umap['saging'] = 'dilaw';
umap['ubas'] = 'berde';
umap['fig'] = 'lila';
intsa isa=umapburahin('ubas');
gastos<<umaplaki() << ' n';
Ang output ay 2.
void swap (unordered_map &)
Ang dalawang hindi nakaayos na mga mapa ay maaaring mapalitan, tulad ng nakalarawan sa segment ng code na ito:
{'ubas', 'berde'}, {'fig', 'lila'}, {'strawberry', 'net'}};
unordered_map<Const char*, Const char*>umap2= {{'seresa', 'net'}, {'dayap', 'berde'}};
umap1.magpalit(umap2);
unordered_map<Const char*, Const char*> ::paulit-ulititer1=umap1.magsimula();
pares<Const char*, Const char*>pr1= *iter1;
unordered_map<Const char*, Const char*> ::paulit-ulititer2=umap2.magsimula();
pares<Const char*, Const char*>pr2= *iter2;
gastos<< 'Unang susi at laki ng umap1:'<<pr1.una <<','<<umap1.laki() << ' n';
gastos<< 'Unang susi at laki ng umap2'<<pr2.una <<','<<umap2.laki() << ' n';
unordered_map<Const char*, Const char*>umap1= {{'saging', 'dilaw'},
{'ubas', 'berde'}, {'fig', 'lila'}, {'strawberry', 'net'}};
unordered_map<Const char*, Const char*>umap2= {{'seresa', 'net'}, {'dayap', 'berde'}};
umap1.magpalit(umap2);
unordered_map<Const char*, Const char*> ::paulit-ulititer1=umap1.magsimula();
pares<Const char*, Const char*>pr1= *iter1;
unordered_map<Const char*, Const char*> ::paulit-ulititer2=umap2.magsimula();
pares<Const char*, Const char*>pr2= *iter2;
gastos<< 'Unang susi at laki ng umap1:'<<pr1.una <<','<<umap1.laki() << ' n';
gastos<< 'Unang susi at laki ng umap2'<<pr2.una <<','<<umap2.laki() << ' n';
Ang output ay:
Unang susi at sukat ng umap1: dayap, 2
Unang key at laki ng umap2 strawberry, 4
Ang mapa ay hindi naka-order. Tandaan na ang haba ng isang mapa ay nadagdagan kung kinakailangan. Ang mga uri ng data ay dapat na pareho.
Klase at mga Instantiated na Bagay nito
Ang isang halaga ay sa isang uri ng data, bilang isang instantiated object ay sa isang klase. Ang hindi naayos na pagtatayo ng mapa ay maaari ring tanggapin ang isang klase bilang isang uri ng data. Inilalarawan ito ng sumusunod na programa:
# isama# isama
gamit ang namespace std;
klase TheCla
{
pampubliko:
intsa isa;
static charch;
walang bisapagpapaandar(charhindi, Const char *p)
{
gastos<< 'Meron' <<sa isa<< 'librong nagkakahalaga' <<hindi<<p<< ' sa tindahan.' << ' n';
}
static walang bisamasaya(charch)
{
kung (ch== 'to')
gastos<< 'Opisyal na pag-andar ng static member' << ' n';
}
};
intpangunahing()
{
TheCla obj1;TheCla obj2;TheCla obj3;TheCla obj4;TheCla obj5;
unordered_map<Const char*,AngCla>umap;
umap= {{'saging',obj1}, {'ubas',obj2}, {'fig',obj3}, {'strawberry',obj4}, {'dayap',obj5}};
gastos<<umaplaki() << ' n';
bumalik ka 0;
}
Ang output ay: 5.
Ang kahulugan ng klase ay may dalawang data na kasapi sa publiko at dalawang pagpapaandar ng pampublikong miyembro. Sa pangunahing () pagpapaandar, iba't ibang mga bagay para sa klase ay instantiated. Ang isang hindi naayos na mapa ay pagkatapos ay natibay, kung saan ang bawat pares ay binubuo ng pangalan ng isang prutas at isang bagay mula sa klase. Ang laki ng mapa ay ipinapakita. Ang programa ay nag-iipon nang walang mensahe ng babala o error.
Paglalapat ng Mapa
Iniuugnay ng array ang isang index sa halaga. Ang mga pares ng key / halaga ay umiiral sa maraming mga sitwasyon sa buhay, na maaaring mai-program. Ang pares ng susi / halaga ng prutas / kulay ay isang halimbawa lamang. Ang isa pang halimbawa ay ang pangalan ng mga tao at kanilang edad. Sa kasong ito, ang pares ay magiging isang uri, pares. Maaari rin itong maging pares. Sa huling kaso, ang direktibong pre-processing ay gagamitin. Ang isang pares ng susi / halaga ay maaari pa ring maging pangalan ng mga mag-asawa. Sa mga bansa kung saan may poligamya, magkakaroon ng magkakaibang asawa para sa isang lalaki.
Pagbuo ng isang Mapa
Ang isang mapa ay hindi isang dalawang-dimensional na array, na may dalawang mga haligi. Gumagawa ang isang mapa na may function na hash. Ang susi ay naka-encode ng pag-andar ng hash, sa isang integer ng isang array. Ang array na ito ang nagtataglay ng mga halaga. Kaya, mayroong talagang isang array na may mga halaga, at ang mga key ay nai-map sa mga indeks ng array, at sa gayon ang mga sulat sa pagitan ng mga key at halaga ay ginawa. Ang Hashing ay isang malawak na paksa at hindi saklaw sa artikulong ito.
Konklusyon
Ang isang mapa, na kilala rin bilang isang nauugnay na array ay isang listahan ng mga elemento, kung saan ang bawat elemento ay isang pares ng key / halaga. Kaya, ang bawat susi ay tumutugma sa isang halaga. Sa C ++, ang mapa ay ipinatupad bilang isang istraktura ng data na may mga pag-andar at operator ng miyembro. Ang isang naka-order na mapa ay isa kung saan ang mga pares ng elemento ay na-order ng mga susi. Ang isang hindi naayos na mapa ay isa kung saan walang pag-order.
Teknikal, ang isang hash ay binubuo ng mga elemento ng pares. Sa katunayan, ang pares ay isang buong istraktura ng data kasama ang mga pag-andar at operator ng miyembro nito. Ang dalawang mga parameter ng template para sa pares ay pareho ng dalawang mga parameter ng template para sa unordered_map.
Ang initializer_list para sa mapa ay isang array na literal ng mga literal. Ang bawat panloob na literal na binubuo ng dalawang mga bagay, ang key / pares ng halaga.
Ang mga pagpapaandar ng miyembro at mga operator para sa unordered_map ay maaaring ikinategorya sa ilalim ng mga sumusunod na heading: unordered_map konstruksyon / kopya ng paggawa, unordered_map Capacity, unordered_map iterator, unordered_map Operations, at unordered_map Modifiers.
Ginagamit ang isang hindi naayos na mapa kapag ang isang susi ay dapat na ma-map sa isang halaga.
Chrys