Unikāli un pasūtīti konteineri C ++

6, 10, 2, 8, 4 ir kopa; 2, 4, 6, 8, 10 ir to pašu veselu skaitļu kopa, kas sakārtota augošā secībā. Matemātikā kopai ir unikāli elementi (atšķirīgi elementi), tas ir, neviens elements nenotiek vairāk kā vienu reizi. Turklāt multiset ir kopa, kurā jebkurš elements var notikt vairāk nekā vienu reizi. 6, 6, 10, 2, 2, 8, 4, 4, 4 ir multiset. 2, 2, 4, 4, 4, 6, 6, 8, 10 ir vienādi multiset, bet ar elementiem sakārtoti augošā secībā. Šis raksts neattiecas uz multiset. Tas nodarbojas ar C ++ datu struktūru, ko sauc par set.

Karte programmatūrā ir kā masīvs, bet tas ir masīvs ar divām kolonnām, nevis vienu. Pirmajā kolonnā ir atslēgas, bet otrajā - vērtības. Katra rinda ir viens pāris, veidojot atslēgu / vērtību pāri. Atslēga ir tieši saistīta ar tās vērtību.

Kartes piemērs ir 'c', 30, 'b', 20, 'd', 30, 'e', 40, 'a', 10. Pirmais šeit ievietotais atslēgu / vērtību pāris ir 'c', 3, kur 'c' ir atslēga un 30 ir vērtība. Šī karte nav sakārtota ar taustiņiem. Pasūtot šo karti ar taustiņiem, iegūst 'a', 10, 'b', 20, 'c', 30, 'd', 30, 'e', 40. Ievērojiet, ka var būt dublētas vērtības, bet ne dublētas atslēgas. Sakārtota karte ir karte, kas sakārtota pēc taustiņiem.

Multiset ir kopa, tāpat kā multimap ir karte. Tas nozīmē, ka ir kartes ar atslēgu dublikātiem. Daudzkartes piemērs ir 'a', 10, 'b', 20, 'b', 20, 'c', 30, 'c', 30, 'd ', 30, ' e ', 40. Kā jau minēts iepriekš, šajā rakstā nav aplūkota multimap, drīzāk tā attiecas uz C ++ datu struktūru, ko sauc par mapi.

C ++ datu struktūra ir struktūra ar īpašībām (datu dalībnieki) un metodēm (dalībnieka funkcijas). Struktūras dati ir saraksts; komplekts ir saraksts; karte ir atslēgu / vērtību pāru saraksts.

Šajā rakstā ir apskatīti kopu un karšu pamati C ++, un, lai labāk izprastu šo rakstu, lasītājam bija jābūt pamatzināšanām par++.

Raksta saturs:

Klase un tās objekti
Komplekta vai kartes izveide
Iteratora pamati
Elements Piekļuve kopai un kartei
Elementu secība komplektā vai kartē
Citas bieži lietotās locekļu funkcijas
Secinājums

Klase un tās objekti:

Programmā C ++ kopu, karti un citas līdzīgas struktūras sauc par konteineriem. Klase ir vispārināta vienība ar datu dalībniekiem, kas ir mainīgie, un dalībnieku funkcijām, kas ir saistītas. Kad datu dalībniekiem tiek piešķirtas vērtības, tiek izveidots objekts. Tomēr objekts tiek veidots procesā, ko sauc par instantiāciju. Tā kā klase var novest pie dažādu vērtību vienam un tam pašam datu dalībnieku mainīgajam, pēc tam vienā un tajā pašā klasē var instantizēt dažādus objektus.

Programmā C ++ nelietojams kopums ir klase, kā arī neizmantojama karte. Kad objekts tiek eksemplārs no neizmantojamās kopas vai neizmantojamās kartes, objekts kļūst par reālo datu struktūru. Izmantojot kopas un kartes datu struktūras, galvenais datu dalībnieks ir saraksts. Nu, kopa un karte veido konteineru grupu, ko sauc par pasūtītiem asociatīviem konteineriem. Pastāv arī nesakārtota kopa un nesakārtota karte, taču tās diemžēl šajā rakstā nav apskatītas.

Komplekta vai kartes izveide:

Instantējot kopu no tās kopas klases, tiek izveidots kopa; ja karte tiek parādīta no tās klases, tiek izveidota karte. Šādi izveidotajam objektam tiek piešķirts nosaukums pēc programmētāja izvēles.

Lai izveidotu kopu, programma jāsāk ar:

# iekļaut
# iekļaut
izmantojot nosaukumvietu std;

Ievērojiet direktīvu “#include ”, Kas ietver kopu bibliotēku, kurai ir iestatītā klase, no kuras tiks kopētas datu struktūras.

Lai izveidotu karti, programma jāsāk ar:

# iekļaut
# iekļaut
izmantojot nosaukumvietu std;

Ievērojiet direktīvu “#include ”, Kurā ietilpst karšu bibliotēka, kurai ir kartes klase, no kuras tiks momentizētas karšu datu struktūras.

Sintakse, lai izveidotu tukšu kopu, ir:

komplekts objectName

Piemērs:

komplekts setObj;

Piemērs, kā izveidot kopu ar saturu, ir šāds:

komplekts setObj (6, 10, 2, 8, 4);

Sintakse tukšas kartes izveidošanai ir šāda:

karte objectName

Piemērs:

karte karteObj;

Kartes ar saturu izveidošanas piemērs ir šāds:

karte mapObj ('c', 30, 'b', 20, 'd', 30, 'e', 40, 'a', 10);

Iteratora pamati:

Iterators ir izstrādāts rādītājs, ko var izmantot, lai pārvietotos datu struktūras sarakstā no sākuma līdz beigām.

Sākuma () locekļa funkcija

Funkcija begin () atgriež iteratoru, kas norāda uz saraksta pirmo elementu. Šis kopas piemērs to ilustrē:

komplekts setObj (6, 10, 2, 8, 4);
komplekts:: iterators iter = setObj.sākt ();
cout << *iter << '\n';

Ņemiet vērā, ka sākuma () veids ir izmantots ar setObj un punktu operatoru. iter ir atgrieztais iteratora objekts. Ievērojiet arī tā deklarēšanas veidu. * ir netiešais operators. Izmantojot iter, tas atgriež kopas pirmo elementu; pirmais elements ir 2, nevis 6 - skatīt paskaidrojumu zemāk.

Šis piemērs ilustrē funkcijas start () izmantošanu kartē:

karte mapObj ('c', 30, 'b', 20, 'd', 30, 'e', 40, 'a', 10);
karte:: iterators iter = karte Obj.sākt ();
cout << "" << (*iter).first <<',' << (*iter).second << "\n";

Ņemiet vērā, ka sākums () ir izmantots ar mapObj un punktu operatoru. iter ir atgrieztais iteratora objekts. Ievērojiet arī tā deklarēšanas veidu. “Pirmais”, kā lietots šeit, attiecas uz atslēgu. “Otrais” attiecas uz vērtību, kas atbilst atslēgai. Ievērojiet, kā tie ir izmantoti ar iter, lai iegūtu saraksta sākuma elementu komponentus. Pirmais elements ir a, 10, nevis c, 30 - skatiet paskaidrojumu zemāk.

Locekļa funkcija “begin () const”

Funkcija “begin () const” atgriež iteratoru, kas norāda uz saraksta pirmo elementu, kad kopas deklarācija sākas ar const (konstantei). Saskaņā ar šo nosacījumu iterators nevar mainīt saraksta vērtību, uz kuru atsaucas atgrieztais iterators. Šis piemērs ilustrē tā izmantošanu komplektam:

const noteikts setObj (6, 10, 2, 8, 4);
komplekts:: const_iterator iter = setObj.sākt ();
cout << *iter << '\n';

Ņemiet vērā, ka sākuma () veids ir izmantots ar setObj un punktu operatoru. Neviens “const” nav ievadīts tieši pēc sākuma (). Tomēr pirms deklarācijas ir “const”. iter šeit ir atgrieztais konstanta iteratora objekts, kas atšķiras no parastā iteratora. Ievērojiet arī tā deklarēšanas veidu. * ir netiešais operators; kā tiek izmantots kopā ar iter, tas atgriež kopas pirmo elementu. Pirmais elements ir 2, nevis 6 - skatīt paskaidrojumu zemāk.

Šis piemērs ilustrē funkcijas “begin () const” izmantošanu kartē:

const karte mapObj ('c', 30, 'b', 20, 'd', 30, 'e', 40, 'a', 10);
karte:: const_iterator iter = karte Obj.sākt ();
cout << "" << (*iter).first <<',' << (*iter).second << "\n";

Ņemiet vērā, ka sākums () ir izmantots ar mapObj un punktu operatoru. Neviens “const” nav ievadīts tieši pēc sākuma (). Tomēr pirms deklarācijas ir “const”. iter šeit ir atgrieztais konstanta iteratora objekts, kas atšķiras no parastā iteratora. Ievērojiet arī tā deklarēšanas veidu. “Pirmais”, kā lietots šeit, attiecas uz atslēgu; Šeit lietotais “otrais” attiecas uz vērtību, kas atbilst atslēgai. Ievērojiet, kā tie ir izmantoti ar iter, lai iegūtu saraksta sākuma elementu komponentus. Pirmais elements ir a, 10, nevis c, 30 - skatiet paskaidrojumu zemāk.

End () locekļa funkcija

Funkcija end () atgriež iteratoru, kas norāda tieši pēc saraksta beigām. Šis kopas piemērs to ilustrē:

komplekts setObj (6, 10, 2, 8, 4);
komplekts:: iterators iter = setObj.beigas ();
cout << *iter << '\n';

Ievērojiet, kā gals () ir izmantots ar setObj un punktu operatoru. iter ir atgrieztais iteratora objekts. Ievērojiet arī tā deklarēšanas veidu. * ir netiešais operators; kā tiek izmantots ar iter, tas atgriež kopas pēdējo + 1 elementu. Autora datorā šis pēdējais + 1 elements ir 5, kas nav sarakstā. Tāpēc uzmanieties, lai neizmantotu šo elementu.

Šis piemērs ilustrē funkcijas end () izmantošanu kartē:

karte mapObj ('c', 30, 'b', 20, 'd', 30, 'e', 40, 'a', 10);
karte:: iterators iter = karte Obj.beigas ();
cout << "" << (*iter).first <<',' << (*iter).second << "\n";

Ievērojiet, kā gals () ir izmantots ar mapObj un punktu operatoru. iter ir atgrieztais iteratora objekts. Ievērojiet arī tā deklarēšanas veidu. * ir netiešais operators; kā tiek izmantots ar iter, tas atgriež kartes pēdējo + 1 elementu. Autora datorā šis pēdējais + 1 elements ir , 0, kura nav sarakstā. Tāpēc uzmanieties, lai neizmantotu šo elementu.

Locekļa “end () const” funkcija

Dalībnieka funkcija “end () const” atgriež atkārtotāju, kas norāda tieši pēc saraksta beigām, kad kopas deklarācija sākas ar const (konstantei). Saskaņā ar šo nosacījumu iterators nevar mainīt saraksta vērtību, uz kuru atsaucas atgrieztais iterators. Šis piemērs ilustrē tā izmantošanu komplektam:

const noteikts setObj (6, 10, 2, 8, 4);
komplekts:: const_iterator iter = setObj.beigas ();
cout << *iter << '\n';

Ievērojiet, kā gals () ir izmantots ar setObj un punktu operatoru. Tieši pēc beigām nav ierakstīts neviens “const”. Tomēr pirms deklarācijas ir “const”. iter ir atgrieztais iteratora objekts. Ievērojiet arī tā deklarēšanas veidu. * ir netiešais operators; kā tiek izmantots ar iter, tas atgriež kopas pēdējo + 1 elementu.

Šis piemērs ilustrē funkcijas “end () const” izmantošanu kartē:

const karte mapObj ('c', 30, 'b', 20, 'd', 30, 'e', 40, 'a', 10);
karte:: const_iterator iter = karte Obj.beigas ();
cout << "" << (*iter).first <<',' << (*iter).second << "\n";

Ievērojiet, kā gals () ir izmantots ar mapObj un punktu operatoru. Tieši pēc beigām nav ierakstīts neviens “const”. Tomēr pirms deklarācijas ir “const”. iter ir atgrieztais konstanta iteratora objekts, kas atšķiras no parastā iteratora. Tāpat uzmanīgi ievērojiet, kā tas ir deklarēts.

Elementa piekļuve kopai un kartei:

Iestatiet

Izmantojot kopu, elements tiek nolasīts, izmantojot indirection operatoru. Pirmie divi kopas elementi ir lasāmi šajā piemērā:

komplekts setObj (6, 10, 2, 8, 4);
komplekts:: iterators iter = setObj.sākt ();
cout << *iter << '\n';
++atkārtot;
cout << *iter << '\n';

Rezultāts ir 2, pēc tam seko 4 - skat. Paskaidrojumu zemāk. Lai norādītu uz nākamo saraksta elementu, atkārtotājs tiek palielināts.

Piezīme: Elementu nevar mainīt, izmantojot komplekta indirection operatoru. Piemēram, “* iter = 9;” nav iespējams.

karte

Karte sastāv no atslēgu / vērtību pāriem. Vērtību var nolasīt, izmantojot atbilstošo atslēgu, un mainīt, izmantojot to pašu atslēgu. To ilustrē šāds koda segments:

karte mapObj ('c', 30, 'b', 20, 'd', 30, 'e', 40, 'a', 10);
cout << mapObj['b'] << '\n';
mapObj ['b'] = 55;
cout << mapObj['b'] << '\n';

Rezultāts ir:

20
55

Punktu operators šeit nav izmantots. Tā vietā ir izmantots kvadrātiekavu operators, kurš atslēgu uztver kā saturu.

Elementu secība komplektā vai kartē:

Elementus var ievietot komplektā jebkurā secībā. Tomēr pēc ievietošanas kopa elementus pārkārto augošā secībā. Augošā secība ir noklusējuma secība. Ja nepieciešama dilstoša secība, kopa ir jādeklarē, kā parādīts šajā piemērā:

komplekts > setObj (6, 10, 2, 8, 4);

Tātad, pēc veida, e.g., int, veidnei ir komats, kam seko “lielāks”Leņķa iekavās.

Elementus kartē var ievietot jebkurā secībā. Tomēr pēc ievietošanas karte pārkārto elementus augošā secībā pēc atslēgas (tikai), vienlaikus saglabājot attiecības starp katru taustiņu un tā vērtību. Augošā secība ir noklusējuma secība; ja nepieciešama dilstoša secība, karte ir jādeklarē, kā parādīts šajā piemērā:

karte > mapObj ('c', 30, 'b', 20, 'd', 30, 'e', 40, 'a', 10);

Tātad, pēc tipa pāra, e.g., “Char, int”, veidnei ir komats, kam seko “lielāks”Leņķa iekavās.

Pārbraucot komplektu

Laika cilpu vai cilpu ar iteratoru var izmantot, lai šķērsotu kopu. Šis piemērs izmanto for-loop, lai šķērsotu kopu, kas ir konfigurēta dilstošā secībā:

komplekts > setObj (6, 10, 2, 8, 4);
par (set:: iterators iter = setObj.sākt (); atkārtot != setObj.beigas (); ++ atkārtojums)

cout << *iter << ";

Rezultāts ir:

10 8 6 4 2

Palielinot atkārtotāju, tas tiek novirzīts uz nākamo elementu.

Pārvietošanās pa karti

Izmantojot cilpu while-loop vai for-loop ar iteratoru, var šķērsot karti. Šis piemērs izmanto for-loop, lai šķērsotu karti, kas konfigurēta dilstošā secībā:

karte > mapObj ('c', 30, 'b', 20, 'd', 30, 'e', 40, 'a', 10);
par (karte:: iterators iter = karte Obj.sākt (); atkārtot != karte Obj.beigas (); ++ atkārtojums)

cout << "" << (*iter).first << ", " << (*iter).second << "" << ", ";

Rezultāts ir:

e, 40, d, 30, c, 30, b, 20, a, 10,

Palielinot atkārtotāju, tas tiek novirzīts uz nākamo elementu. “Pirmais” kodā attiecas uz atslēgu, bet “otrais” - uz atbilstošo vērtību. Ievērojiet, kā šīs vērtības ir iegūtas izvadam.

Citas bieži lietotās locekļa funkcijas:

Izmērs () Funkcija

Šī funkcija atgriež veselu skaitli, kas ir elementu skaits sarakstā. Rādīt piemēru:

komplekts > setObj (6, 10, 2, 8, 4);
cout << setObj.size() << '\n';

Rezultāts ir 5.

Kartes piemērs:

karte > mapObj ('c', 30, 'b', 20, 'd', 30, 'e', 40, 'a', 10);
cout << mapObj.size() << '\n';

Rezultāts ir 5.

Funkcija Insert ()

komplekts

set neatļauj dublikātu. Tātad visi ievietotie dublikāti tiek klusi noraidīti. Izmantojot kopu, funkcijas insert () arguments ir ievietojamā vērtība. Vērtība ir uzstādīta pozīcijā, kurā secība komplektā paliek augoša vai dilstoša. Piemērs:

komplekts setObj (6, 10, 2, 8, 4);
setObj.ievietot (6);
setObj.ievietot (9);
setObj.ievietot (12);
par (set:: iterators iter = setObj.sākt (); atkārtot != setObj.beigas (); ++ atkārtojums)

cout << *iter << ";

Rezultāts ir:

2 4 6 8 9 10 12

Piezīme: Funkciju insert () var izmantot, lai aizpildītu tukšu kopu.

karte

karte nepieļauj dublēšanu pēc atslēgas. Tātad visi ievietotie dublikāti tiek klusi noraidīti. Izmantojot karti, funkcijas insert () arguments ir atslēgu / vērtību pāris iekavās. Elements tiek ievietots pozīcijā ar atslēgu, kurā kartes kārtība paliek augoša vai dilstoša. Piemērs:

karte mapObj ('c', 30, 'b', 20, 'd', 30, 'e', 40, 'a', 10);
karte Obj.ievietot ('e', 80);
karte Obj.ievietot ('f', 50);
karte Obj.ievietot ('g', 60);
par (karte:: iterators iter = karte Obj.sākt (); atkārtot != karte Obj.beigas (); ++ atkārtojums)
cout << "" << (*iter).first << ", " << (*iter).second << "" << ", ";

Rezultāts ir:

a, 10, b, 20, c, 30, d, 30, e, 40, f, 50, g, 60,

Piezīme: Funkciju insert () var izmantot, lai aizpildītu tukšu karti.

Tukšā () funkcija

Šī funkcija atgriež vērtību true, ja saraksts ir tukšs, un false, ja citādi. Rādīt piemēru:

komplekts setObj (6, 10, 2, 8, 4);
bool ret = setObj.tukšs ();
cout << ret << '\n';

Izvade ir 0, ja nepareiza vērtība nozīmē, ka šeit iestatītā kopa nav tukša.

Kartes piemērs:

karte mapObj ('c', 30, 'b', 20, 'd', 30, 'e', 40, 'a', 10);
bool ret = karte Obj.tukšs ();
cout << ret << '\n';

Izvade ir 0, ja nepareiza vērtība, tātad karte šeit nav tukša.

Dzēšanas funkcija

komplekts

Apsveriet šādu koda segmentu:

komplekts setObj (10, 20, 30, 40, 50);
komplekts:: iterators iter = setObj.sākt ();
komplekts:: iterators itr = setObj.dzēst (atkārtot);
cout << "new size: " << setObj.size() << '\n';
cout << "next value: " << *itr << '\n';
itr = setObj.dzēst (itr);
cout << "new size: " << setObj.size() << '\n';
cout << "next value: " << *itr << '\n';

Rezultāts ir:

jauns izmērs: 4
nākamā vērtība: 20
jauns izmērs: 3
nākamā vērtība: 30

Funkcija erase () prasa iteratoru, kas norāda uz elementu kā argumentu. Pēc elementa dzēšanas funkcija erase () atgriež atkārtotāju, kas norāda uz nākamo elementu.

karte

Apsveriet šādu koda segmentu:

karte mapObj ('a', 10, 'b', 20, 'c', 30, 'd', 40, 'e', 50);
karte:: iterators iter = karte Obj.sākt ();
karte:: iterators itr = karte Obj.dzēst (atkārtot);
cout << "new size: " << mapObj.size() << '\n';
cout << "next value pair: " << (*itr).first <<',' << (*itr).second << "\n";
itr = karte Obj.dzēst (itr);
cout << "new size: " << mapObj.size() << '\n';
cout << "next value pair: " << (*itr).first <<',' << (*itr).second << "\n";

Rezultāts ir:

jauns izmērs: 4
nākamais vērtību pāris: b, 20
jauns izmērs: 3
nākamais vērtību pāris: c, 30

Funkcija erase () prasa iteratoru, kas norāda uz elementu kā argumentu. Pēc elementa dzēšanas funkcija erase () atgriež atkārtotāju, kas norāda uz nākamo elementu.

Skaidra () funkcija

Funkcija clear () noņem visus saraksta elementus. Rādīt piemēru:

komplekts setObj (6, 10, 2, 8, 4);
setObj.skaidrs ();
cout << setObj.size() << '\n';

Rezultāts ir 0.

kartes piemērs:

karte mapObj ('c', 30, 'b', 20, 'd', 30, 'e', 40, 'a', 10);
karte Obj.skaidrs ();
cout << mapObj.size() << '\n';

Rezultāts ir 0.

Secinājums:

Noteikta datu struktūra C ++ ir struktūra, kurā elementu saraksts pēc noklusējuma tiek saglabāts augošā secībā vai pēc programmētāja izvēles dilstošā secībā. Visi komplekta elementi ir unikāli. Kartes datu struktūra C ++ ir struktūra, kurā saraksts ir atslēgu / vērtību pāru jaukšana, kas pēc noklusējuma tiek glabāta atslēgu augošā secībā vai pēc programmētāja izvēles dilstošā secībā. Atslēgas ir arī unikālas, un vērtības var būt dublētas. Jebkuras struktūras galvenais datu dalībnieks ir saraksts. Jebkurai struktūrai ir dalībnieku funkcijas, no kurām dažas parasti tiek izmantotas.