Kuidas C ++ vektorit kasutada

Sissejuhatus

Massiiv on samade objektitüüpide rida järjestikustes mälukohtades. Maatriks ei saa maagi pikkust suurendada. Vektor on nagu massiiv, kuid selle pikkust saab suurendada või vähendada. Seetõttu on vektoril palju rohkem toiminguid kui massiivil.

C ++-l on palju teeke, mis kõik moodustavad C ++ Standard Library. Üks neist raamatukogudest on konteinerraamatukogu. Konteiner on objektide kogum ja kollektsiooniga saab teha teatud toiminguid. C ++ konteinereid saab rühmitada kahte komplekti: järjestuskonteinerid ja assotsiatiivsed konteinerid. Järjestuskonteinerid on vektor, massiiv (mitte sama massiiv, mida eelnevalt käsitleti), deque, forward_list ja list. Need on erinevad kogumid (massiivitaolised andmestruktuurid) ja igaüks pakub erinevaid kompromisse.

Iga programmeerija peaks teadma, kuidas otsustada, kas kasutada vektorit, massiivi, deque'i, forward_listit või loendit. Kui programmeerija vajab struktuuri, mis nõuab rohkem toiminguid kui tavalise massiiviga seotud, ei tohiks tavalist massiivi kasutada.

Kui ülesanne hõlmab sagedasi sisestusi ja kustutusi jada keskel, tuleks kasutada loendit või edasisuunamisloendit. Kui ülesanne hõlmab sagedasi sisestusi ja kustutusi jada alguses või lõpus, siis tuleks kasutada deque. Kui selliseid toiminguid pole vaja, tuleks kasutada vektorit.

See artikkel näitab teile, kuidas C ++ vektorit kasutada. Selle artikli mõistmiseks vajate mõningaid teadmisi C ++ osutitest, viidetest ja massiividest.

Klass ja objektid

Klass on koos töötavate muutujate ja funktsioonide kogum, kus muutujatel pole väärtusi määratud. Kui muutujatele määratakse väärtused, saab klass objektiks. Samale klassile antud erinevad väärtused toovad kaasa erinevad objektid; see tähendab, et erinevad objektid võivad kuuluda samasse klassi, kuid neil on erinevad väärtused. Klassist objekti loomine on tuntud ka kui objekti kiirendamine.

Termin vektor kirjeldab klassi. Vektorist loodud objektil on nimi, mille valib programmeerija.

Klassile kuuluva funktsiooni olemasolu on vajalik objekti klassist kiirendamiseks. C ++ versioonis on sellel funktsioonil sama nimi kui klassi nimel. Erinevatel klassi loodud (eksponeeritud) objektidel on programmeerija poolt igale neist eraldatud erinevad nimed.

Klassist objekti loomine tähendab objekti ehitamist; see tähendab ka objekti kiirendamist.

Vektorklass

Vektorklass on juba määratletud ja asub teegis. Vektorklassi kasutamiseks peab programmeerija lisama faili vektoripäise järgmise eeltöötlusdirektiiviga:

# kaasata

Kui päis on lisatud, muutuvad ligipääsetavaks kõik vektorfunktsioonid (andmeliikmed ja liikme funktsioonid). Count-objekti kasutamiseks terminali (konsooli) andmete väljastamiseks tuleb lisada ka objekti päis. Vektoriga programmi kirjutamiseks tuleb lisada vähemalt järgmised päised:

# kaasata
# kaasata

Vektori käivitamine

int foo [10];

Eespool on massiivi deklaratsioon nimega "foo" ja elementide arvuga "10.”See on täisarvude massiiv. Vektori deklaratsioon on sarnane. Vektori jaoks on elementide arv valikuline, kuna vektori pikkus võib suureneda või väheneda.

Programmi selles punktis on vektorklass juba teegis määratletud ja päis on kaasatud. Vektorit saab instantsida järgmiselt:

std: vektor vtr (8);

Siin on vektor spetsiaalse konstruktori funktsiooniga. Andmete tüüp, mida vektor hoiab, on nurksulgudes „int“. Mõiste “vtr” on nimi, mille programmeerija valis vektori jaoks. Lõpuks on sulgudes "8" esialgne arv täisarvusid, mis vektoril on.

Mõiste “std” tähistab standardset nimeruumi. Sellele terminile peab antud kontekstis järgnema kahekordne koolon. Igaüks saab kirjutada oma vektorklasside kogu ja seda kasutada. Kuid C ++ - l on juba standardraamatukogu standardsete nimedega, sealhulgas „vektor.”Standardnime kasutamiseks peab standardnime ees olema täht std :: . Std :: iga kord programmis standardnime kirjutamise vältimiseks võib programmifail alata järgmiselt:

# kaasata
# kaasata
nimeruumi kasutamine std;

Funktsiooni ülekoormamine

Kui kahel või enamal erineval funktsiooniallkirjal on sama nimi, öeldakse, et see nimi on ülekoormatud. Ühe funktsiooni kutsumisel määrab täidetava funktsiooni argumentide arv ja tüüp.

Vektori ehitamine

Vektori konstrueerimine tähendab vektorobjekti instantsimist (loomist). Konstruktori funktsioon on ülekoormatud järgmiselt:

vektor nimi

Nii luuakse vektor pikkusega null ja tüüp „T.Järgmine lause loob nullpikkuse tüübi “float” vektori nimega “vtr:”

vektor vtr;

vektor nimi (n)

Nii luuakse vektor, millel on n tüüpi „T“ elementi.”Selle nelja ujukelemendiga vektori avaldus on järgmine:

vektor vtr (4);

vektor nimi (n, t)

See loob n elemendist koosneva vektori, mis initsialiseeritakse väärtusele t. Järgmine lause loob viiest elemendist koosneva vektori, kus iga elemendi väärtus on 3.4:

vektor vtr (5, 3.4);

Ehitamine initsialiseerimisega

Vektorit saab samaaegselt konstrueerida (luua) ja initsialiseerida ühel järgmistest kahest viisist:

vektor vtr = 1.1, 2.2, 3.3, 4.4;

Või

vektor vtr 1.1, 2.2, 3.3, 4.4;

Pange tähele, et vahetult objekti nime järel pole sulge. Sulgudel, mida kasutatakse vahetult pärast objekti nime, peaks olema initsiaatorite loend järgmiselt:

vektor vtr (1.1, 2.2, 3.3, 4.4);

Vektorit saab konstrueerida ja initsialiseerida hiljem initsiaatorite loendi abil. Sel juhul sulge ei kasutata:

vektor vtr;
vtr = 1.1, 2.2, 3.3, 4.4;

vektor V2 (V1)

See on koopiaehitaja. See loob vektori V1 koopiana vektori V2. Järgmine kood illustreerib seda:

vektor vtr1 (5, 3.4);
vektor vtr2 (vtr1);

Vektori määramine ehituse ajal

Ehitamise ajal saab luua tühja vektori, samal ajal kui sellele on määratud teine vektor järgmiselt:

vektor vtr1 1.1, 2.2, 3.3, 4.4;
vektor vtr2 = vtr1;

Teine väide on samaväärne järgmisega:

vektor vtr2 = 1.1, 2.2, 3.3, 4.4;

const Vektor

Konst vektor on vektor, mille elemente ei saa muuta. Selle vektori väärtused on kirjutuskaitstud. Selle loomisel ilmub vektor järgmiselt:

const vektor vtr 1.1, 2.2, 3.3, 4.4;

Selles vektoritüübis ei saa ühtegi elementi lisada ega eemaldada. Pealegi ei saa väärtust muuta.

Iteratoriga ehitamine

Mall pakub andmetüübile üldise esituse. Iteraator esitab konteineri väärtuste kaudu skannimise üldise kujutise. Iteraatoriga vektori loomise süntaks on järgmine:

mall
vektor (kõigepealt InputIterator, viimane InputIterator, const Allocator & = Allocator ());

See konstrueerib vahemiku [esimene, viimane] vektori määratud eraldaja abil, mida käsitletakse edaspidi selles artiklis.

Vektori hävitamine

Vektori hävitamiseks laske sellel lihtsalt reguleerimisalast välja minna ja hävitamine toimub automaatselt.

Vektorimaht

size_type maht () const noexcept

Elementide koguarv, mida vektor mahutab ilma ümberjaotamist nõudmata, tagastatakse mahtuvusliikme funktsiooniga. Selle koodisegment on järgmine:

vektor vtr (4);
int arv = vtr.mahutavus ();
cout << num << '\n';

Väljund on 4.

reserv (n)

Mäluruum pole alati vabalt saadaval. Lisaruumi saab ette broneerida. Mõelge järgmisele koodisegmendile:

vektor vtr (4);
vtr.reserv (6);
cout << vtr.capacity() << '\n';

Väljund on 6. Niisiis, reserveeritud lisaruum on 6 - 4 = 2 elementi. Funktsioon tagastab kehtetu.

suurus () const noexcept

See tagastab vektoris olevate elementide arvu. Seda funktsiooni illustreerib järgmine kood:

vektor vtr (4);
ujuk sz = vtr.suurus ();
cout << sz << '\n';

Väljund on 4.

shrink_to_fit ()

Pärast reservi () funktsiooniga vektorile lisavõimsuse andmist saab vektori suurust vähendada, et see sobiks selle algse suurusega. Järgmine kood illustreerib seda:

vektor vtr (4);
vtr.reserv (6);
vtr.shrink_to_fit ();
int sz = vtr.suurus ();
cout << sz << '\n';

Väljund on 4 ja mitte 6. Funktsioon tagastab kehtetu.

suuruse muutmine (sz), suuruse muutmine (sz, c)

See muudab vektori suurust. Kui uus suurus on väiksem kui vana, siis kustutatakse lõpu poole jäävad elemendid. Kui uus suurus on pikem, lisatakse lõpupoole mõni vaikeväärtus. Konkreetse lisaväärtuse saamiseks kasutage funktsiooni Resize () kahe argumendiga. Järgmine koodisegment illustreerib nende kahe funktsiooni kasutamist:

vektor vtr1 1.1, 2.2, 3.3, 4.4;
vtr1.muuta suurust (2);
cout << "New size of vtr1: " << vtr1.size() << '\n';
vektor vtr2 1.1, 2.2;
vtr2.suuruse muutmine (4, 8.8);
cout << "vtr2: "<< vtr2[0] <<" "<< vtr2[1] <<"
"<< vtr2[2] <<" "<< vtr2[3] << '\n';

Väljund on järgmine:

Uus vtr1 suurus: 2
vtr2: 1.1 2.2 8.8 8.8

Funktsioonid tühistatakse.

tühi () const noexcept

See funktsioon tagastab tõese 1, kui vektoris pole elemente, ja 0 vale, kui vektor on tühi. Kui vektoril on teatud tüüpi andmetele, näiteks ujukile, 4 asukohta, ilma ujukväärtuseta, siis pole see vektor tühi. Järgmine kood illustreerib seda:

vektor vtr;
cout << vtr.empty() << '\n';
vektor vt (4);
cout << vt.empty() << '\n';
vektor v (4,3.5);
cout << v.empty() << '\n';

Väljund on järgmine:

1
0
0

Juurdepääs vektorelementidele

Vektorit saab skriptida (indekseerida) nagu massiiv. Indeksite loendamine algab nullist.

vektorinimi [i]

Operatsioon "vectorName [i]" tagastab viite elemendis i^th vektori indeks. Järgmised koodiväljundid 3.3 ülaltoodud vektori korral:

vektor vtr 1.1, 2.2, 3.3, 4.4;
ujuk fl = vtr [2];
cout << fl << '\n';

vektorNimi [i] konst

Kui vektor on konstantne vektor, täidetakse operatsioon „vectorName [i] const” „vectorName [i]” asemel. Seda toimingut kasutatakse järgmises koodis:

const vektor vtr 1.1, 2.2, 3.3, 4.4;
ujuk fl = vtr [2];
cout << fl << '\n';

Avaldis tagastab püsiva viite i-le^th vektori element.

Väärtuse määramine alamindeksiga

Mittekonstantvektorile saab väärtuse määrata järgmiselt:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vtr [2] = 8.8;
cout << vtr[2] << '\n';

Väljund on 8.8.

vektorNimi.juures (i)

„VectorName.juures (i) ”on nagu„ vektorinimi [i] ”, kuid„ vektorinimi.punktis (i) ”on usaldusväärsem. Järgmine kood näitab, kuidas seda vektorit tuleks kasutada:

vektor vtr 1.1, 2.2, 3.3, 4.4;
ujuk fl = vtr.juures (2);
cout << fl << '\n';
at () on vektorliikme funktsioon.

vektorNimi.juures (i) konst

„VectorName.at (i) const "on nagu" vectorName [i] const ", kuid" vectorName.at (i) const ”on usaldusväärsem. „VectorName.at (i) const täidetakse „vectorName“ asemel.juures (i) ”, kui vektor on konstantne vektor. Seda vektorit kasutatakse järgmises koodis:

const vektor vtr 1.1, 2.2, 3.3, 4.4;
ujuk fl = vtr.juures (2);
cout << fl << '\n';
at () const on vektorliikme funktsioon.

Väärtuse määramine funktsiooniga at ()

Funktsiooniga at () saab mittekonstantvektorile omistada väärtuse järgmiselt:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vtr.juures (2) = 8.8;
cout << vtr[2] << '\n';

Väljund on 8.8.

Alamskriptimise probleem

Alamskriptimise (indekseerimise) probleem seisneb selles, et kui indeks on vahemikust väljas, võidakse nulli tagastada või käivitamise ajal võidakse anda viga.

ees ()

See tagastab viite vektori esimesele elemendile ilma elementi eemaldamata. Järgmise koodi väljund on 1.1.

vektor vtr 1.1, 2.2, 3.3, 4.4;
ujuk fl = vtr.esikülg ();
cout << fl << '\n';

Elementi vektorist ei eemaldata.

ees () const

Kui vektori konstrueerimisele eelneb const, täidetakse väljendi „front () asemel väljend„ front () const ”.”Seda kasutatakse järgmises koodis:

const vektor vtr 1.1, 2.2, 3.3, 4.4;
ujuk fl = vtr.esikülg ();
cout << fl << '\n';

Tagastatakse pidev viide. Elementi vektorist ei eemaldata.

tagasi()

See tagastab viite vektori viimasele elemendile ilma elementi eemaldamata. Järgmise koodi väljund on 4.4.

vektor vtr 1.1, 2.2, 3.3, 4.4;
ujuk fl = vtr.tagasi();
cout << fl << '\n';

tagasi () konst

Kui vektori konstrueerimisele eelneb const, täidetakse väljendi „back () const” asemel „back ().”Seda kasutatakse järgmises koodis:

const vektor vtr 1.1, 2.2, 3.3, 4.4;
ujuk fl = vtr.tagasi();
cout << fl << '\n';

Tagastatakse pidev viide. Elementi vektorist ei eemaldata.

Vektorandmete juurdepääs

andmed () noexcept; andmed () const noexcept;

Mõlemad neist tagastavad kursori, nii et [data (), data () + size ()) on kehtiv vahemik.

Seda käsitletakse üksikasjalikumalt hiljem artiklis.

Naasevad itaatorid ja vektor

Iteraator on nagu osuti, kuid sellel on rohkem funktsionaalsust kui kursoril.

alusta () noexcept

Tagastab iteraatori, mis osutab vektori esimesele elemendile, nagu järgmises koodisegmendis:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vektor:: iteraator iter = vtr.algama ();
cout << *iter << '\n';

Väljund on 1.1. Pange tähele, et deklaratsioon, mis kordaja võtab, on deklareeritud. Iteraator on tagastusavalduses viidatud väärtuse saamiseks samamoodi, nagu osutatakse kursorile.

begin () const noexcept;

Tagastab iteraatori, mis osutab vektori esimesele elemendile. Kui vektori konstrueerimisele eelneb const, käivitatakse väljendi “begin () const asemel”.”Selles tingimuses ei saa vektori vastavat elementi muuta. Seda kasutatakse järgmises koodis:

const vektor vtr 1.1, 2.2, 3.3, 4.4;
vektor:: const_iterator iter = vtr.algama ();
cout << *iter << '\n';

Väljund on 1.1. Pange tähele, et tagastatud iteraatori vastuvõtmiseks on seekord kasutatud lihtsalt "iteraatorit" asemel "const_iterator".

lõpp () noexcept

Tagastab iteraatori, mis osutab kohe vektori viimasest elemendist kaugemale. Mõelge järgmisele koodisegmendile:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vektor:: iteraator iter = vtr.lõpp();
cout << *iter << '\n';

Väljundiks on 0, mis on mõttetu, kuna viimasest elemendist kaugemal pole konkreetset elementi.

end () const noexcept

Tagastab iteraatori, mis osutab kohe vektori viimasest elemendist kaugemale. Kui vektori konstrueerimisele eelneb “const”, täidetakse väljendi “end () asemel väljend“ end () const ”."Mõelge järgmisele koodisegmendile:

const vektor vtr 1.1, 2.2, 3.3, 4.4;
vektor:: const_iterator iter = vtr.lõpp();
cout << *iter << '\n';

Väljund on 0. Pange tähele, et tagastatud iteraatori vastuvõtmiseks on seekord kasutatud lihtsalt "iteraatorit" asemel "const_iterator".

Pöördkordus

Võimalik on iteraator, mis kordub lõpust vahetult enne esimest elementi.

rbegin () noexcept

Tagastab iteraatori, mis osutab vektori viimasele elemendile, nagu järgmises koodisegmendis:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vektor:: reverse_iterator rIter = vtr.rbegin ();
cout << *rIter << '\n';

Väljund on 4.4.

Pange tähele, et deklaratsioon, mis võtab vastu iteraatori, on deklareeritud. Iteraator on tagastusavalduses viidatud väärtuse saamiseks samamoodi, nagu osutatakse kursorile.

rbegin () const noexcept;

Tagastab iteraatori, mis osutab vektori viimasele elemendile. Kui vektori konstrueerimisele eelneb „const”, käivitatakse „rbegin ()” asemel väljend „rbegin () const”.”Selles tingimuses ei saa vektori vastavat elementi muuta. Seda funktsiooni kasutatakse järgmises koodis:

const vektor vtr 1.1, 2.2, 3.3, 4.4;
vektor:: const_reverse_iterator rIter = vtr.rbegin ();
cout << *rIter << '\n';

Väljund on 4.4.

Pange tähele, et tagastatud iteraatori saamiseks on seekord kasutatud lihtsalt reverse_iteraatori asemel const_reverse_iteratorit.

rend () noexcept

Tagastab iteraatori, mis osutab vahetult enne vektori esimest elementi. Mõelge järgmisele koodisegmendile:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vektor:: reverse_iterator rIter = vtr.rend ();
cout << *rIter << '\n';

Väljundiks on 0, mis on mõttetu, kuna vahetult enne esimest elementi pole konkreetset elementi.

rend () const noexcept

Tagastab iteraatori, mis osutab vahetult enne vektori esimest elementi. Kui vektori konstrueerimisele eelneb „const”, käivitatakse „rend ()” asemel väljend „rend () const”."Mõelge järgmisele koodisegmendile:

const vektor vtr 1.1, 2.2, 3.3, 4.4;
vektor:: const_reverse_iterator rIter = vtr.rend ();
cout << *rIter << '\n';

Väljund on 0.

Pange tähele, et tagastatud iteraatori saamiseks on seekord kasutatud mitte ainult reverse_iteratorit, vaid const_reverse_iteratorit.

Vektori modifikaatorid

Vektorit modifitseeriv modifikaator võib võtta iteraatori või tagastada selle.

a.töökoht (p, args)

Lisab objekti tüüp T, mis on konstrueeritud std :: forward(args) ... enne lk.

Üksikasjad - vt hiljem

sisesta (iteratorPositsioon, väärtus)

Lisab väärtuse koopia vektori iteraatori positsiooni. Tagastab iteraatori (positsiooni) vektoris, kuhu koopia on paigutatud. Järgmine kood näitab, kuhu väärtus on paigutatud:

vektor vtr 10, 20, 30, 40;
vektor:: iteraator iter = vtr.algama ();
++iter;
++iter;
vtr.sisestada (iter, 25);
cout << vtr[1] << " << vtr[2]<< '
" << vtr[3] << '\n';

Väljund on: 20 25 30.

Pange tähele, et iteraator oli arenenud (suurendatud) täpselt nagu osuti.

Samuti saab lisada initsialistide loendi, nagu illustreerib järgmine kood:

vektor vtr 10, 20, 30, 40;
vektor:: iteraator iter = vtr.algama ();
++iter;
++iter;
vtr.sisesta (iter, 25, 28);
cout << vtr[1] << " << vtr[2]<< '
" << vtr[3]<< " << vtr[4] << '\n';

Väljund on: 20 25 28 30.

kustuta (asend)

Eemaldab elemendi iteraatori osutatavas positsioonis ja tagastab seejärel iteraatori positsiooni. Järgmine kood illustreerib seda:

vektor vtr 10, 20, 30, 40;
vektor:: iteraator iter = vtr.algama ();
++iter;
++iter;
vtr.kustutada (iter);
cout << vtr[0] << " << vtr[1] << '
" << vtr[2]<< '\n';

Väljund on: 10 20 40

tagasitõmbamine (t), tagasitõmbamine (rv)

Kasutatakse ühe elemendi lisamiseks vektori lõppu. Kasutage push_back (t) järgmiselt:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vtr.tagasilükkamine (5.5);
ujuk fl = vtr [4];
cout << fl << '\n';

Väljund on 5.5.

push_back (rv): - vaata hiljem.

pop_back ()

Eemaldab viimase elemendi seda tagastamata. Vektori suurust vähendatakse 1 võrra. Järgmine kood illustreerib seda:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vtr.pop_back ();
ujuk sz = vtr.suurus ();
cout << sz << '\n';

Väljund on 3.

a.vahetada (b)

Kaks vektorit saab vahetada, nagu on illustreeritud järgmises koodisegmendis:

vektor vtr1 1.1, 2.2, 3.3, 4.4;
vektor vtr2 10, 20;
vtr1.vahetada (vtr2);
cout << "vtr1: "<< vtr1[0] <<" "<< vtr1[1] <<"
"<< vtr1[2] <<" "<< vtr1[3] << '\n';
cout << "vtr2: "<< vtr2[0] <<" "<< vtr2[1] <<"
"<< vtr2[2] <<" "<< vtr2[3] << '\n';

Väljund on:

vtr1: 10 20 0 0
vtr2: 1.1 2.2 3.3 4.4

Pange tähele, et vajadusel suurendatakse vektori pikkust. Samuti asendatakse väärtused, millel ei olnud asendusi, mõne vaikeväärtusega.

selge ()

Eemaldab vektorist kõik elemendid, nagu illustreerib järgmine koodilõik:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vtr.selge ();
cout << vtr.size() << '\n';

Väljund on 0.

Vektorite võrdõiguslikkus ja suhtekorraldajad

== Operaator

Tagastab tõese 1, kui kahel vektoril on sama suurus ja vastavad elemendid on võrdsed; vastasel juhul tagastab vale väärtuseks 0. Näiteks:

vektor U 1, 2, 3;
vektor V 4, 5, 6;
bool bl = U == V;
cout << bl << '\n';

Väljund on 0.

The != Operaator

Tagastab tõese 1, kui kahel vektoril ei ole sama suurust ja / või vastavad elemendid pole võrdsed; vastasel juhul tagastab vale väärtuseks 0. Näiteks:

vektor U 1, 2, 3;
vektor V 4, 5, 6;
bool bl = U!= V;
cout << bl << '\n';

Väljund on 1.

The < Operator

Tagastab tõese 1, kui esimene vektor on teise vektori alghulk, kusjuures kahe võrdse osa elemendid on samad ja samas järjekorras. Kui mõlemad vektorid on sama suurusega ja liiguvad vasakult paremale ning esimeses vektoris leidub element, mis on väiksem kui vastava elemendi teises vektoris, tagastatakse ikkagi 1. Vastasel juhul tagastatakse vale väärtus 0. Näiteks:

vektor U 3, 1, 1;
vektor V 3, 2, 1;
bool bl = Ucout << bl << '\n';

Väljund on 1. < does not include the case when the size and order are the same.

Operaator

Tagastab !(U < V), where U is the first vector and V is the second vector, according to the above definitions.

The <= Operator

Tagastab U <= V, where U is the first vector and V is the second vector, according to the above definitions.

Operaator> =

Tagastab !(U <= V), where U is the first vector and V is the second vector, according to the above definitions.

Järeldus

Vektor on järjestusemahuti näide. Vektor on tavalise massiivi "parem" vorm ja see on klassist eksemplar. Vektoritel on meetodid, mis on liigitatud kategooriasse: ehitus ja määramine, maht, juurdepääs elementidele, andmetele juurdepääs, iteraatorid, teisendajad ja arvulised ülekoormatud operaatorid.

On ka teisi jadakonteinereid, mida nimetatakse nimekirjaks, edastamisloendiks ja massiiviks. Kui ülesanne hõlmab sagedasi sisestusi ja kustutusi jada keskel, tuleks kasutada loendit või edasisuunamisloendit. Kui ülesanne hõlmab sagedasi sisestamisi ja kustutamisi jada alguses või lõpus, tuleks kasutada deque. Seega tuleks vektoreid kasutada ainult siis, kui sellised toimingud pole olulised.