Kako uporabljati C ++ Vector

How Use C Vector



Uvod

Niz je vrsta istih vrst objektov na zaporednih lokacijah pomnilnika. Polje ne more povečati zmanjšanja rude po dolžini. Vektor je kot matrika, vendar se njegova dolžina lahko poveča ali zmanjša. Vektor ima zato veliko več operacij kot matrika.

C ++ ima veliko knjižnic, od katerih vse tvorijo standardno knjižnico C ++. Ena od teh knjižnic je knjižnica vsebnikov. Vsebnik je zbirka predmetov in na zbirki je mogoče izvesti določene operacije. Vsebnike C ++ lahko združimo v dva niza: vsebniške zaporedje in asociativne vsebnike. Vsebniki zaporedja so vektorski, matrični (ni isti niz, o katerem smo govorili prej), deque, forward_list in list. To so različne zbirke (matrične strukture podatkov) in vsaka ponuja različne kompromise.







Vsak programer bi se moral odločiti, ali bo uporabil vektor, matriko, deque, forward_list ali seznam. Kadar programer potrebuje strukturo, ki zahteva več operacij kot tiste, povezane z navadnim nizom, ga ne bi smeli uporabljati.



Če naloga vključuje pogosto vstavljanje in brisanje sredi zaporedja, je treba uporabiti seznam ali forward_list. Če naloga vključuje pogosto vstavljanje in brisanje na začetku ali koncu zaporedja, je treba uporabiti deque. Če te vrste operacij niso potrebne, je treba uporabiti vektor.



Ta članek vam pokaže, kako uporabljati vektor C ++. Za razumevanje tega članka boste potrebovali nekaj znanja o kazalcih C ++, referencah in matrikah.





Razred in predmeti

Razred je niz spremenljivk in funkcij, ki delujejo skupaj, pri čemer spremenljivkam nimajo dodeljenih vrednosti. Ko so spremenljivkam dodeljene vrednosti, postane razred objekt. Različne vrednosti, podane istemu razredu, povzročijo različne predmete; to pomeni, da so lahko različni predmeti istega razreda, vendar imajo različne vrednosti. Ustvarjanje predmeta iz razreda je znano tudi kot ustvarjanje predmeta.

Izraz vektor opisuje razred. Objekt, ustvarjen iz vektorja, ima ime, ki ga izbere programer.



Funkcija, ki pripada razredu, je potrebna za ustvarjanje predmeta iz razreda. V C ++ ima ta funkcija isto ime kot ime razreda. Različni predmeti, ustvarjeni (nastali) iz razreda, imajo različna imena, ki jim jih da programer.

Ustvarjanje predmeta iz razreda pomeni konstruiranje predmeta; pomeni tudi instanciranje predmeta.

Vektorski razred

Vektorski razred je že definiran in je v knjižnici. Za uporabo vektorskega razreda mora programer vključiti vektorsko glavo v datoteko z naslednjo direktivo o predhodni obdelavi:

#vključi

Ko je glava vključena, postanejo dostopne vse vektorske funkcije (podatkovni člani in funkcije članov). Če želite uporabiti predmet count za izpis podatkov v terminal (konzolo), mora biti vključena tudi glava objekta. Če želite napisati program z vektorjem, morate vključiti vsaj naslednje glave:

#vključi
#vključi

Ustvarjanje vektorja

intfoo[10];

Zgoraj je deklaracija niza z imenom foo in številom elementov 10. To je niz celih števil. Izjava vektorja je podobna. Za vektor je število elementov neobvezno, saj se lahko dolžina vektorja poveča ali zmanjša.

Na tej točki programa je bil vektorski razred že definiran v knjižnici in vključena je glava. Vektor lahko namestite na naslednji način:

ure::vektor <int>vtr(8);

Tu je vektor posebne konstrukcijske funkcije. Vrsta podatkov, ki jih bo vektor hranil, je int, v kotnih oklepajih. Izraz vtr je ime, ki ga je programer izbral za vektor. Nazadnje je 8 v oklepaju okvirno število celih števil, ki jih bo imel vektor.

Izraz std pomeni standardni imenski prostor. Temu izrazu mora v tem kontekstu slediti dvojno dvopičje. Vsakdo lahko napiše svojo knjižnico vektorskih razredov in jo uporablja. Vendar ima C ++ že standardno knjižnico s standardnimi imeni, vključno z vektorskimi. Za uporabo standardnega imena mora biti pred standardnim imenom std ::. Da se izognete tipkanju std :: vsakič v programu za standardno ime, se lahko programska datoteka začne na naslednji način:

#vključi
#vključi
z uporabo imenskega prostora std;

Preobremenitev funkcije

Kadar imata dva ali več različnih podpisov funkcij isto ime, je to ime preobremenjeno. Ko se pokliče ena funkcija, število in vrsta argumentov določata, katera funkcija se izvaja.

Sestavljanje vektorja

Konstruiranje vektorja pomeni ustvarjanje (ustvarjanje) vektorskega predmeta. Konstruktorska funkcija je preobremenjena na naslednji način:

vektorsko ime

Tako nastane vektor dolžine nič in tipa T. Naslednja izjava ustvari vektor ničelne dolžine tipa float z imenom vtr:

vektor<plavati>vtr;

vektorsko ime (n)

Tako nastane vektor z n elementi tipa T. Izjava za ta vektor s štirimi plavajočimi elementi je naslednja:

vektor<plavati>vtr(4);

vektorsko ime (n, t)

Tako nastane vektor n elementov, inicializiranih na vrednost t. Naslednja izjava ustvari vektor 5 elementov, pri čemer ima vsak element vrednost 3,4:

vektor<plavati>vtr(5, 3.4);

Konstrukcija z inicializacijo

Vektor je mogoče hkrati konstruirati (ustvariti) in inicializirati na enega od naslednjih dveh načinov:

vektor<plavati>vtr= {1.1, 2.2, 3.3, 4.4};

Or

vektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};

Upoštevajte, da oklepajev za imenom predmeta ni. Okrogli oklepaji, ki se uporabljajo tik za imenom predmeta, morajo imeti seznam inicializatorjev:

vektor<plavati>vtr({1.1, 2.2, 3.3, 4.4});

Vektor lahko pozneje sestavite in inicializirate s seznamom inicializatorjev. V tem primeru oklepaji ne bodo uporabljeni:

vektor<plavati>vtr;
vtr= {1.1, 2.2, 3.3, 4.4};

vektor V2 (V1)

To je konstruktor kopiranja. Ustvari vektor V2 kot kopijo vektorja V1. Naslednja koda ponazarja to:

vektor<plavati>vtr1(5, 3.4);
vektor<plavati>vtr2(vtr1);

Dodelitev vektorja med gradnjo

Med gradnjo lahko ustvarite prazen vektor, drugi pa mu dodeli:

vektor<plavati>vtr1{1.1, 2.2, 3.3, 4.4};
vektor<plavati>vtr2=vtr1;

Druga izjava je enakovredna:

vektor<plavati>vtr2= {1.1, 2.2, 3.3, 4.4};

const Vector

Const vektor je vektor, katerega elementov ni mogoče spremeniti. Vrednosti v tem vektorju so samo za branje. Ko je ustvarjen, se vektor prikaže na naslednji način:

constvektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};

V tej vrsti vektorja ni mogoče dodati ali odstraniti nobenega elementa. Poleg tega ni mogoče spremeniti nobene vrednosti.

Konstrukcija z Iteratorjem

Predloga ponuja splošen prikaz podatkovnega tipa. Ponavljalnik ponuja splošen prikaz skeniranja skozi vrednosti vsebnika. Sintaksa za ustvarjanje vektorja z iteratorjem je naslednja:

predlogo<razred InputIterator>
vektor(Najprej InputIterator,InputIterator zadnji,constRazdeljevalec& =Razdeljevalec());

Ta konstruira vektor za obseg [prvi, zadnji) z uporabo podanega razdeljevalnika, o katerem bomo razpravljali kasneje v tem članku.

Uničenje vektorja

Če želite uničiti vektor, preprosto pustite, da izstopi iz področja uporabe, uničenje pa se obravnava samodejno.

Vektorska zmogljivost

size_type capacity () const noexcept

Skupno število elementov, ki jih vektor lahko zadrži, ne da bi jih bilo treba prerazporediti, vrne funkcija člana zmogljivosti. Odsek kode za to je naslednji:

vektor<plavati>vtr(4);
intna enem=vtr.zmogljivosti();
stroški<<na enem<< ' n';

Izhod je 4.

rezerva (n)

Pomnilniški prostor ni vedno prosto dostopen. Dodatni prostor je mogoče rezervirati vnaprej. Razmislite o naslednjem segmentu kode:

vektor<plavati>vtr(4);
vtr.rezerva(6);
stroški<<vtr.zmogljivosti() << ' n';

Izhod je 6. Torej je rezerviran dodaten prostor 6 - 4 = 2 elementa. Funkcija vrne void.

size () const noexcept

To vrne število elementov v vektorju. Naslednja koda ponazarja to funkcijo:

vektor<plavati>vtr(4);
plavatis=vtr.velikost();
stroški<<s<< ' n';

Izhod je 4.

shrink_to_fit ()

Po dodajanju dodatne kapacitete vektorju s funkcijo Reserve () lahko vektor pomanjšamo tako, da ustreza njegovi prvotni velikosti. Naslednja koda ponazarja to:

vektor<plavati>vtr(4);
vtr.rezerva(6);
vtr.shrink_to_fit();
ints=vtr.velikost();
stroški<<s<< ' n';

Izhod je 4 in ne 6. Funkcija vrne void.

spremeniti velikost (sz), spremeniti velikost (sz, c)

S tem spremenite velikost vektorja. Če je nova velikost manjša od stare velikosti, se elementi proti koncu izbrišejo. Če je nova velikost daljša, se proti koncu doda nekaj privzete vrednosti. Za dodano vrednost uporabite funkcijo resize () z dvema argumentoma. Naslednji kodni segment ponazarja uporabo teh dveh funkcij:

vektor<plavati>vtr1{1.1, 2.2, 3.3, 4.4};
vtr1.spremenite velikost(2);
stroški<< 'Nova velikost vtr1:' <<vtr1.velikost() << ' n';
vektor<plavati>vtr2{1.1, 2.2};
vtr2.spremenite velikost(4, 8.8);
stroški<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'
<<vtr2[2] <<''<<vtr2[3] << ' n';

Izhod je naslednji:

Nova velikost vtr1: 2
vtr2: 1,1 2,2 8,8 8,8

Funkcije vrnejo void.

empty () const noexcept

Ta funkcija vrne 1 za true, če v vektorju ni elementov in 0 za false, če je vektor prazen. Če ima vektor 4 lokacije za določeno vrsto podatkov, na primer float, brez vrednosti float, potem ta vektor ni prazen. Naslednja koda ponazarja to:

vektor<plavati>vtr;
stroški<<vtr.prazno() << ' n';
vektor<plavati>vt(4);
stroški<<tako daprazno() << ' n';

vektor<plavati>v(4,3.5);
stroški<<v.prazno() << ' n';

Izhod je naslednji:

1
0
0

Dostop do vektorskih elementov

Vektor je lahko podnapisan (indeksiran) kot matrika. Štetje indeksov se začne od nič.

vectorName [i]

Operacija vectorName [i] vrne sklic na element pri ithindeks vektorja. Naslednja koda daje 3.3 za zgornji vektor:

vektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};
plavatifl=vtr[2];
stroški<<fl<< ' n';

vectorName [i] const

Operacija vectorName [i] const se izvede namesto vectorName [i], kadar je vektor konstanten vektor. Ta operacija se uporablja v naslednji kodi:

constvektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};
plavatifl=vtr[2];
stroški<<fl<< ' n';

Izraz vrne konstantno referenco na ithelement vektorja.

Dodelitev vrednosti s podpisom

Vrednost, ki ni konstantna, je mogoče dodeliti na naslednji način:

vektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};
vtr[2] = 8.8;
stroški<<vtr[2] << ' n';

Izhod je 8,8.

vectorName.at (i)

vectorName.at (i) je podoben vectorName [i], vendar je vectorName.at (i) bolj zanesljiv. Naslednja koda prikazuje, kako je treba uporabiti ta vektor:

vektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};
plavatifl=vtr.ob(2);
stroški<<fl<< ' n';
ob()je vektorski članfunkcijo.

vectorName.at (i) const

vectorName.at (i) const je podoben vectorName [i] const, vendar je vectorName.at (i) const bolj zanesljiv. vectorName.at (i) const se izvede namesto vectorName.at (i), kadar je vektor konstanten vektor. Ta vektor se uporablja v naslednji kodi:

constvektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};
plavatifl=vtr.ob(2);
stroški<<fl<< ' n';
ob() constje vektorski članfunkcijo.

Dodelitev vrednosti s funkcijo at ()

Vrednost, ki ni konstantna, je mogoče dodeliti s funkcijo at (), kot sledi:

vektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};
vtr.ob(2) = 8.8;
stroški<<vtr[2] << ' n';

Izhod je 8,8.

Težava s podnapisi

Težava s podnapisi (indeksiranjem) je, da če je indeks izven obsega, se lahko vrne nič ali pa se med izvajanjem prikaže napaka.

spredaj ()

To vrne sklic na prvi element vektorja, ne da bi odstranili element. Izhod naslednje kode je 1.1.

vektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};
plavatifl=vtr.spredaj();
stroški<<fl<< ' n';

Element ni odstranjen iz vektorja.

spredaj () const

Ko je vektorski konstrukciji pred const, se namesto front () izvede izraz front () const. To se uporablja v naslednji kodi:

constvektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};
plavatifl=vtr.spredaj();
stroški<<fl<< ' n';

Vrne se stalna referenca. Element ni odstranjen iz vektorja.

nazaj ()

To vrne sklic na zadnji element vektorja, ne da bi odstranili element. Izhod naslednje kode je 4.4.

vektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};
plavatifl=vtr.nazaj();
stroški<<fl<< ' n';

nazaj () const

Ko je pred vektorsko konstrukcijo pred const, se namesto back () izvede izraz back () const. To se uporablja v naslednji kodi:

constvektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};
plavatifl=vtr.nazaj();
stroški<<fl<< ' n';

Vrne se stalna referenca. Element ni odstranjen iz vektorja.

Dostop do vektorskih podatkov

data () noexcept; data () const noexcept;

Vsaka od teh vrne kazalec, tako da je [data (), data () + size ()) veljaven obseg.

To bo podrobneje obravnavano kasneje v članku.

Vrnjeni iteratorji in vektor

Ponavljalec je kot kazalec, vendar ima več funkcij kot kazalec.

begin () noexcept

Vrne iterator, ki kaže na prvi element vektorja, kot v naslednjem kodnem segmentu:

vektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};
vektor<plavati> ::iteratoriter=vtr.začeti();
stroški<< *iter<< ' n';

Izhod je 1,1. Upoštevajte, da je bila deklaracija, ki prejme iterator, deklarirana. Ponavljalnik se v povratnem izrazu razveljavi, da dobi vrednost na enak način, kot je kazalec razvezan.

begin () const noexcept;

Vrne iterator, ki kaže na prvi element vektorja. Ko je pred vektorsko konstrukcijo pred const, se namesto begin () izvede izraz begin () const. Pod tem pogojem ustreznega elementa v vektorju ni mogoče spremeniti. To se uporablja v naslednji kodi:

constvektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};
vektor<plavati> ::const_iteratoriter=vtr.začeti();
stroški<< *iter<< ' n';

Izhod je 1,1. Upoštevajte, da je bil const_iterator tokrat uporabljen namesto samo iteratorja za sprejem vrnjenega iteratorja.

end () noexcept

Vrne iterator, ki kaže neposredno onkraj zadnjega elementa vektorja. Razmislite o naslednjem segmentu kode:

vektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};
vektor<plavati> ::iteratoriter=vtr.konec();
stroški<< *iter<< ' n';

Izhod je 0, kar je nesmiselno, saj poleg zadnjega elementa ni nobenega konkretnega elementa.

end () const noexcept

Vrne iterator, ki kaže neposredno onkraj zadnjega elementa vektorja. Ko je pred vektorsko konstrukcijo konst, se namesto end () izvede izraz end () const. Razmislite o naslednjem segmentu kode:

constvektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};
vektor<plavati> ::const_iteratoriter=vtr.konec();
stroški<< *iter<< ' n';

Izhod je 0. Upoštevajte, da je bil tokrat namesto samo iteratorja uporabljen const_iterator za sprejem vrnjenega iteratorja.

Povratna ponovitev

Možno je imeti iterator, ki se ponavlja od konca do tik pred prvim elementom.

rbegin () noexcept

Vrne iterator, ki kaže na zadnji element vektorja, kot v naslednjem kodnem segmentu:

vektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};
vektor<plavati> ::reverse_iteratorreter=vtr.rbegin();
stroški<< *reter<< ' n';

Izhod je 4,4.

Upoštevajte, da je bila deklaracija, ki prejme povratni iterator, deklarirana. Ponavljalnik se v povratnem izrazu razveljavi, da dobi vrednost na enak način, kot je kazalec razvezan.

rbegin () const noexcept;

Vrne iterator, ki kaže na zadnji element vektorja. Ko je pred vektorsko konstrukcijo konst, se namesto rbegin () izvede izraz rbegin () const. Pod tem pogojem ustreznega elementa v vektorju ni mogoče spremeniti. Ta funkcija se uporablja v naslednji kodi:

constvektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};
vektor<plavati> ::const_reverse_iteratorreter=vtr.rbegin();
stroški<< *reter<< ' n';

Izhod je 4,4.

Upoštevajte, da je bil za sprejem vrnjenega iteratorja tokrat namesto samo reverse_iterator uporabljen const_reverse_iterator.

render () noexcept

Vrne iterator, ki kaže tik pred prvim elementom vektorja. Razmislite o naslednjem segmentu kode:

vektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};
vektor<plavati> ::reverse_iteratorreter=vtr.naredi();
stroški<< *reter<< ' n';

Izhod je 0, kar je brez pomena, saj tik pred prvim elementom ni konkretnega elementa.

render () const noexcept

Vrne iterator, ki kaže tik pred prvim elementom vektorja. Ko je pred vektorsko konstrukcijo konst, se namesto rend () izvede izraz rend () const. Razmislite o naslednjem segmentu kode:

constvektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};
vektor<plavati> ::const_reverse_iteratorreter=vtr.naredi();
stroški<< *reter<< ' n';

Izhod je 0.

Upoštevajte, da je bil za sprejem vrnjenega iteratorja tokrat namesto samo reverse_iterator uporabljen const_reverse_iterator.

Vektorski modifikatorji

Modifikator, ki spreminja vektor, lahko sprejme ali vrne iterator.

a.emplace (p, args)

Vstavi objekt tipa T, zgrajen s std :: forward (args) ... pred p.

Za podrobnosti - glej kasneje

insert (iteratorPosition, value)

Vstavi kopijo vrednosti v položaj iteratorja vektorja. Vrne iterator (položaj) v vektorju, kjer je bila kopija postavljena. Naslednja koda prikazuje, kje je bila vrednost postavljena:

vektor<int>vtr{10, dvajset, 30, 40};
vektor<int> ::iteratoriter=vtr.začeti();
++iter;
++iter;
vtr.vstavi(iter, 25);
stroški<<vtr[1] << '' <<vtr[2]<< '
'
<<vtr[3] << ' n';

Izhod je: 20 25 30.

Upoštevajte, da je bil iterator napreden (povečan) tako kot kazalec.

Lahko vstavite tudi seznam inicializatorjev, kot prikazuje naslednja koda:

vektor<int>vtr{10, dvajset, 30, 40};
vektor<int> ::iteratoriter=vtr.začeti();
++iter;
++iter;
vtr.vstavi(iter, {25, 28});

stroški<<vtr[1] << '' <<vtr[2]<< '
'
<<vtr[3]<< '' <<vtr[4] << ' n';

Izhod je: 20 25 28 30.

brisanje (položaj)

Odstrani element na položaju, na katerega kaže iterator, nato vrne položaj iteratorja. Naslednja koda ponazarja to:

vektor<int>vtr{10, dvajset, 30, 40};
vektor<int> ::iteratoriter=vtr.začeti();
++iter;
++iter;
vtr.izbrisati(iter);
stroški<<vtr[0] << '' <<vtr[1] << '
'
<<vtr[2]<< ' n';

Izhod je: 10 20 40

push_back (t), push_back (rv)

Uporablja se za dodajanje enega samega elementa na koncu vektorja. Uporabite push_back (t) na naslednji način:

vektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};
vtr.porini nazaj(5.5);
plavatifl=vtr[4];
stroški<<fl<< ' n';

Izhod je 5,5.

porini nazaj(rv): -glej kasneje.

pop_back ()

Odstrani zadnji element, ne da bi ga vrnil. Velikost vektorja se zmanjša za 1. To ponazarja naslednja koda:

vektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};
vtr.pop_back();
plavatis=vtr.velikost();
stroški<<s<< ' n';

Izhod je 3.

a.swap (b)

Dva vektorja lahko zamenjate, kot je prikazano v naslednjem kodnem segmentu:

vektor<plavati>vtr1{1.1, 2.2, 3.3, 4.4};
vektor<plavati>vtr2{10, dvajset};
vtr1.zamenjati(vtr2);
stroški<< 'vtr1:'<<vtr1[0] <<''<<vtr1[1] <<'
'
<<vtr1[2] <<''<<vtr1[3] << ' n';

stroški<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'
<<vtr2[2] <<''<<vtr2[3] << ' n';

Izhod je:

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

Upoštevajte, da se dolžina vektorja po potrebi poveča. Prav tako se vrednosti, ki niso imele zamenjav, nadomestijo z neko privzeto vrednostjo.

jasno ()

Odstrani vse elemente iz vektorja, kot prikazuje naslednji kodni segment:

vektor<plavati>vtr{1.1, 2.2, 3.3, 4.4};
vtr.jasno();
stroški<<vtr.velikost() << ' n';

Izhod je 0.

Operatorji enakosti in relacije za vektorje

Operater ==

Vrne 1 za true, če imata dva vektorja enako velikost in sta ustrezna elementa enaka; v nasprotnem primeru vrne 0 za false. Na primer:

vektor<int>U{1, 2, 3};
vektor<int>V{4, 5, 6};
bool bl=U==V;
stroški<<bl<< ' n';

Izhod je 0.

! = Operater

Vrne 1 za true, če vektorja nimata enake velikosti in/ali ustrezna elementa nista enaka; v nasprotnem primeru vrne 0 za false. Na primer:

vektor<int>U{1, 2, 3};
vektor<int>V{4, 5, 6};
bool bl=U! =V;
stroški<<bl<< ' n';

Izhod je 1.

The

Vrne 1 za true, če je prvi vektor začetna podmnožica drugega vektorja, pri čemer sta elementa dveh enakih delov enaka in v istem vrstnem redu. Če sta oba vektorja enake velikosti in se premikata od leve proti desni in se v prvem vektorju sreča element, ki je manjši od ustreznega elementa v drugem vektorju, se 1 še vedno vrne. V nasprotnem primeru se vrne 0 za false. Na primer:

vektor<int>U{3, 1, 1};
vektor<int>V{3, 2, 1};
bool bl=U<V;
stroški<<bl<< ' n';

Izhod je 1.

> Operater

Vrne se! (U

The<= Operator

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

Operater> =

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

Zaključek

Vektor je primer vsebnika zaporedja. Vektor je boljša oblika navadnega niza in je izveden iz razreda. Vektorji imajo metode, ki so razvrščene pod: konstrukcija in dodelitev, zmogljivost, dostop do elementov, dostop do podatkov, iteratorji, modifikatorji in številski preobremenjeni operaterji.

Obstajajo še drugi vsebniki zaporedja, imenovani list, forward_list in array. Če naloga vključuje pogosto vstavljanje in brisanje sredi zaporedja, je treba uporabiti seznam ali forward_list. Če naloga vključuje pogosto vstavljanje in brisanje na začetku ali koncu zaporedja, je treba uporabiti deque. Zato je treba vektorje uporabljati le, kadar tovrstne operacije niso pomembne.