Kuidas kasutada C ++ vektorit

How Use C Vector

Sissejuhatus

Massiiv on samade objektitüüpide jada järjestikustes mälukohtades. Massiiv ei saa maagi pikkust vähendada. Vektor on nagu massiiv, kuid selle pikkust saab suurendada või vähendada. Vektoril on seega palju rohkem toiminguid kui massiiv.

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



Iga programmeerija peaks teadma, kuidas otsustada, kas kasutada vektorit, massiivi, deki, forward_list 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 keskele, siis tuleks kasutada loendit või forward_list. Kui ülesanne hõlmab jada algusesse või lõppu sagedasi sisestamisi ja kustutamisi, tuleks kasutada dekki. Vektorit tuleks kasutada, kui seda tüüpi toiminguid ei nõuta.



See artikkel näitab teile, kuidas kasutada C ++ vektorit. Selle artikli mõistmiseks vajate mõningaid teadmisi C ++ viitade, viidete ja massiivide kohta.

Klass ja objektid

Klass on koos toimivate muutujate ja funktsioonide kogum, kus muutujatele pole määratud väärtusi. Kui muutujatele määratakse väärtused, muutub klass objektiks. Samale klassile antud erinevad väärtused annavad erinevaid objekte; see tähendab, et erinevad objektid võivad kuuluda samasse klassi, kuid neil on erinevad väärtused. Objekti loomine klassist on tuntud ka kui objekti loomine.

Mõiste vektor kirjeldab klassi. Vektorist loodud objektil on nimi, mille valib programmeerija.



Funktsioon, mis kuulub klassi, on vajalik objekti klassist eraldamiseks. C ++ puhul on sellel funktsioonil sama nimi kui klassi nimel. Erinevatel klassist loodud (näidatud) objektidel on programmeerija igaühele eraldi nimed.

Klassist objekti loomine tähendab objekti konstrueerimist; see tähendab ka objekti kohesust.

Vektoriklass

Vektoriklass on juba määratletud ja see on raamatukogus. Vektoriklassi kasutamiseks peab programmeerija lisama faili päise järgmise eeltöötlusdirektiiviga:

#kaasake

Kui päis on lisatud, muutuvad kõik vektorfunktsioonid (andmeliikmed ja liikmefunktsioonid) juurdepääsetavaks. Loendiobjekti kasutamiseks terminalile (konsoolile) andmete väljastamiseks tuleb lisada ka objekti päis. Vektoriga programmi kirjutamiseks tuleb lisada vähemalt järgmised päised:

#kaasake
#kaasake

Vektori juurutamine

intloll[10];

Eespool on massiivi deklaratsioon nimega foo ja elementide arv 10. See on täisarvude massiiv. Vektori deklareerimine on sarnane. Vektori puhul on elementide arv vabatahtlik, kuna vektori pikkus võib suureneda või väheneda.

Programmi praegusel hetkel on vektoriklass raamatukogus juba määratletud ja päis lisatud. Vektori saab esile kutsuda järgmiselt:

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

Siin on vektor konstruktori erifunktsioon. Andmete tüüp, mida vektor hoiab, on int, nurksulgudes. Mõiste vtr on programmeerija valitud vektorile antud nimi. Lõpuks 8, sulgudes, on esialgne arv vektoreid.

Mõiste std tähistab standardset nimeruumi. Sellele terminile peab järgnema kahekordne koolon. Igaüks saab kirjutada oma vektoriklassi raamatukogu ja seda kasutada. C ++ -l on aga juba standardne raamatukogu, millel on standardsed nimed, sealhulgas vektor. Standardnime kasutamiseks peab standardnime ees olema std ::. Et vältida standardnime sisestamist programmis std ::, võib programmifail alata järgmiselt.

#kaasake
#kaasake
kasutades nimeruumi std;

Funktsiooni ülekoormamine

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

Vektori konstrueerimine

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

vektori nimi

See loob vektori, mille pikkus on null ja tüüp T. Järgnev avaldis loob nullpikkusega vektori tüüpi ujuk nimega vtr:

vektor<hõljuma>vtr;

vektori nimi (n)

See loob vektori, milles on n -tüüpi T -tüüpi elemente. Selle nelja ujukielemendiga vektori avaldus on järgmine:

vektor<hõljuma>vtr(4);

vektori nimi (n, t)

See loob n elemendist vektori, mis on lähtestatud väärtusele t. Järgmine väide loob 5 elemendiga vektori, kus iga elemendi väärtus on 3,4:

vektor<hõljuma>vtr(5, 3.4);

Ehitamine initsialiseerimisega

Vektori saab konstrueerida (luua) ja lähtestada samal ajal ühel järgmistest viisidest.

vektor<hõljuma>vtr= {1.1, 2.2, 3.3, 4.4};

Või

vektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};

Pange tähele, et sulgi ei ole vahetult pärast objekti nime. Vahetult pärast objekti nime kasutatavates sulgudes peaks olema initsialiseerijate loend, mis on järgmine:

vektor<hõljuma>vtr({1.1, 2.2, 3.3, 4.4});

Vektori saab konstrueerida ja initsialiseerida hiljem lähtestamisloendiga. Sel juhul sulgusid ei kasutata:

vektor<hõljuma>vtr;
vtr= {1.1, 2.2, 3.3, 4.4};

vektor V2 (V1)

See on koopiakonstruktor. See loob vektori V2 vektori V1 koopiana. Seda illustreerib järgmine kood:

vektor<hõljuma>vtr1(5, 3.4);
vektor<hõljuma>vtr2(vtr1);

Vektori määramine ehituse ajal

Ehitamise ajal saab tühja vektori luua, samas kui sellele määratakse järgmine, järgmiselt:

vektor<hõljuma>vtr1{1.1, 2.2, 3.3, 4.4};
vektor<hõljuma>vtr2=vtr1;

Teine avaldus on samaväärne:

vektor<hõljuma>vtr2= {1.1, 2.2, 3.3, 4.4};

const vektor

Const vektor on vektor, mille elemente ei saa muuta. Selle vektori väärtused on kirjutuskaitstud. Loomisel kuvatakse vektor järgmiselt:

constvektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};

Selle vektoritüübi korral ei saa ühtegi elementi lisada ega eemaldada. Lisaks ei saa väärtust muuta.

Ehitamine Iteraatoriga

Mall pakub andmetüübi üldist esitlust. Iteraator annab üldise kujutise konteineri väärtuste skannimisest. Iteraatoriga vektori loomise süntaks on järgmine:

malli<klassi InputIterator>
vektor(Esiteks InputIterator,InputIterator viimane,constAllokaator& =Allokaator());

See konstrueerib vahemiku [esimene, viimane] jaoks vektori, kasutades määratud jaoturit, mida arutatakse hiljem selles artiklis.

Vektori hävitamine

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

Vektorimaht

size_type capacity () const noexcept

Elementide koguarv, mida vektor võib ümber paigutamata hoida, tagastatakse läbilaskevõime liikme funktsiooniga. Selle jaoks on koodisegment järgmine:

vektor<hõljuma>vtr(4);
intühe peale=vtr.võimsus();
maksma<<ühe peale<< ' n';

Väljund on 4.

reserv (n)

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

vektor<hõljuma>vtr(4);
vtr.reservi(6);
maksma<<vtr.võimsus() << ' n';

Väljund on 6. Seega on lisaruumi reserveeritud 6 - 4 = 2 elementi. Funktsioon tagastab tühja.

size () const noexcept

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

vektor<hõljuma>vtr(4);
hõljumas=vtr.suurus();
maksma<<s<< ' n';

Väljund on 4.

shrink_to_fit ()

Pärast reservi () funktsiooniga vektorile lisamahtuvuse andmist saab vektori suuruse vähendada selle algsesse suurusse. Seda illustreerib järgmine kood:

vektor<hõljuma>vtr(4);
vtr.reservi(6);
vtr.kokkutõmbumisvastane();
ints=vtr.suurus();
maksma<<s<< ' n';

Väljund on 4 ja mitte 6. Funktsioon tagastab tühja.

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

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

vektor<hõljuma>vtr1{1.1, 2.2, 3.3, 4.4};
vtr1.suurust muuta(2);
maksma<< 'Uus vtr1 suurus:' <<vtr1.suurus() << ' n';
vektor<hõljuma>vtr2{1.1, 2.2};
vtr2.suurust muuta(4, 8.8);
maksma<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'
<<vtr2[2] <<''<<vtr2[3] << ' n';

Väljund on järgmine:

Vtr1: 2 uus suurus
vtr2: 1.1 2.2 8.8 8.8

Funktsioonid tagastatakse tühjaks.

tühi () const noexcept

See funktsioon tagastab väärtuse 1 väärtuse tõene, kui vektoris pole elemente, ja väärtuse 0, kui vektor on tühi. Kui vektoril on teatud tüüpi andmete, näiteks ujuki jaoks 4 asukohta ilma ujukiväärtuseta, pole see vektor tühi. Seda illustreerib järgmine kood:

vektor<hõljuma>vtr;
maksma<<vtr.tühi() << ' n';
vektor<hõljuma>vt(4);
maksma<<nii ettühi() << ' n';

vektor<hõljuma>v(4,3.5);
maksma<<v.tühi() << ' n';

Väljund on järgmine:

1
0
0

Juurdepääs vektori elementidele

Vektori saab alamskripteerida (indekseerida) nagu massiivi. Indeksite lugemine algab nullist.

vektorNimi [i]

Operatsioon vectorName [i] tagastab viite elemendile i -sthvektori indeks. Järgmine kood väljub 3.3 ülaltoodud vektori jaoks:

vektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};
hõljumafl=vtr[2];
maksma<<fl<< ' n';

vectorName [i] const

Operatsioon vectorName [i] const täidetakse vektorName [i] asemel, kui vektor on konstantvektor. Seda toimingut kasutatakse järgmises koodis:

constvektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};
hõljumafl=vtr[2];
maksma<<fl<< ' n';

Avaldis tagastab pideva viite i -lethvektori element.

Väärtuse määramine alaindeksi abil

Mittekonstantsele vektorile saab määrata väärtuse järgmiselt.

vektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};
vtr[2] = 8.8;
maksma<<vtr[2] << ' n';

Väljund on 8,8.

vectorName.at (i)

vectorName.at (i) on nagu vectorName [i], kuid vectorName.at (i) on usaldusväärsem. Järgmine kood näitab, kuidas seda vektorit tuleks kasutada:

vektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};
hõljumafl=vtr.kl(2);
maksma<<fl<< ' n';
kl()on vektorliigefunktsiooni.

vectorName.at (i) const

vectorName.at (i) const on nagu vectorName [i] const, kuid vectorName.at (i) const on usaldusväärsem. vectorName.at (i) const täidetakse vektorName.at (i) asemel, kui vektor on konstantvektor. Seda vektorit kasutatakse järgmises koodis:

constvektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};
hõljumafl=vtr.kl(2);
maksma<<fl<< ' n';
kl() conston vektorliigefunktsiooni.

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

Väärtuse saab määrata mittekonstantsele vektorile funktsiooniga at () järgmiselt.

vektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};
vtr.kl(2) = 8.8;
maksma<<vtr[2] << ' n';

Väljund on 8,8.

Probleem alamskriptimisega

Alamskriptimise (indekseerimise) probleem on see, et kui indeks on vahemikust väljas, võidakse null tagastada või käivitamisel ilmneda tõrge.

ees ()

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

vektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};
hõljumafl=vtr.ees();
maksma<<fl<< ' n';

Elementi ei eemaldata vektorist.

ees () const

Kui vektorkonstruktsioonile eelneb const, täidetakse front () asemel avaldis front () const. Seda kasutatakse järgmises koodis:

constvektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};
hõljumafl=vtr.ees();
maksma<<fl<< ' n';

Pidev viide tagastatakse. Elementi ei eemaldata vektorist.

tagasi()

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

vektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};
hõljumafl=vtr.tagasi();
maksma<<fl<< ' n';

tagasi () konst

Kui vektorkonstruktsioonile eelneb const, täidetakse back () asemel avaldis back () const. Seda kasutatakse järgmises koodis:

constvektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};
hõljumafl=vtr.tagasi();
maksma<<fl<< ' n';

Pidev viide tagastatakse. Elementi ei eemaldata vektorist.

Juurdepääs vektorandmetele

data () noexcept; data () const noexcept;

Kumbki neist tagastab kursori selliselt, et [andmed (), andmed () + suurus ()) on kehtiv vahemik.

Seda käsitletakse üksikasjalikumalt artiklis hiljem.

Tagasipöörduvad iteraatorid ja vektor

Iteraator on nagu osuti, kuid sellel on rohkem funktsioone kui osuti.

algus () noexcept

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

vektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};
vektor<hõljuma> ::iteraatoriter=vtr.alustada();
maksma<< *iter<< ' n';

Väljund on 1.1. Pange tähele, et iteraatori saanud deklaratsioon on deklareeritud. Iteraatorile lisatakse tagasivõtmisavaldises väärtus, et saada väärtus samamoodi nagu osuti.

begin () const noexcept;

Tagastab iteraatori, mis osutab vektori esimesele elemendile. Kui vektorkonstruktsioonile eelneb konst, käivitatakse avaldise algus () const asemel (()). Selle tingimuse korral ei saa vektori vastavat elementi muuta. Seda kasutatakse järgmises koodis:

constvektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};
vektor<hõljuma> ::const_iteratoriter=vtr.alustada();
maksma<< *iter<< ' n';

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

end () noexcept

Tagastab iteraatori, mis osutab kohe vektori viimase elemendi taha. Mõelge järgmisele koodilõigule:

vektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};
vektor<hõljuma> ::iteraatoriter=vtr.lõpp();
maksma<< *iter<< ' n';

Väljund on 0, mis on mõttetu, kuna peale viimase elemendi pole ühtegi konkreetset elementi.

end () const noexcept

Tagastab iteraatori, mis osutab kohe vektori viimase elemendi taha. Kui vektorkonstruktsioonile eelneb const, täidetakse end () asemel avaldist end () const. Mõelge järgmisele koodilõigule:

constvektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};
vektor<hõljuma> ::const_iteratoriter=vtr.lõpp();
maksma<< *iter<< ' n';

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

Vastupidine kordamine

Võimalik on iteraator, mis kordub lõpust kuni esimese elemendini.

rbegin () noexcept

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

vektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};
vektor<hõljuma> ::reverse_iteratorvanem=vtr.rbegin();
maksma<< *vanem<< ' n';

Väljund on 4,4.

Pange tähele, et deklaratsioon, mis saab vastupidise iteraatori, on deklareeritud. Iteraatorile lisatakse tagasivõtmisavaldises väärtus, et saada väärtus samamoodi nagu osuti.

rbegin () const noexcept;

Tagastab iteraatori, mis osutab vektori viimasele elemendile. Kui vektorkonstruktsioonile eelneb const, täidetakse rbegin () asemel avaldis rbegin () const. Selle tingimuse korral ei saa vektori vastavat elementi muuta. Seda funktsiooni kasutatakse järgmises koodis:

constvektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};
vektor<hõljuma> ::const_reverse_iteratorvanem=vtr.rbegin();
maksma<< *vanem<< ' n';

Väljund on 4,4.

Pange tähele, et tagastatud iteraatori vastuvõtmiseks on seekord kasutatud mitte ainult tagasipööratud_iteraatorit, vaid konstantse tagasipööramise_iteraatorit.

render () noexcept

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

vektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};
vektor<hõljuma> ::reverse_iteratorvanem=vtr.teeb();
maksma<< *vanem<< ' n';

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

render () const noexcept

Tagastab iteraatori, mis osutab vahetult enne vektori esimest elementi. Kui vektorkonstruktsioonile eelneb const, täidetakse rend () asemel avaldis rend () const. Mõelge järgmisele koodilõigule:

constvektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};
vektor<hõljuma> ::const_reverse_iteratorvanem=vtr.teeb();
maksma<< *vanem<< ' n';

Väljund on 0.

Pange tähele, et tagastatud iteraatori vastuvõtmiseks on seekord kasutatud ainult tagasipööratud_iteraatori asemel Const_reverse_iterator.

Vektorite muutjad

Modifikaator, mis muudab vektorit, võib iteraatori võtta või tagastada.

a. mall (p, args)

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

Üksikasjad - vaata hiljem

insert (iteratorPosition, value)

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

vektor<int>vtr{10, kakskümmend, 30, 40};
vektor<int> ::iteraatoriter=vtr.alustada();
++iter;
++iter;
vtr.sisestada(iter, 25);
maksma<<vtr[1] << '' <<vtr[2]<< '
'
<<vtr[3] << ' n';

Väljund on: 20 25 30.

Pange tähele, et iteraatorit edendati (suurendati) nagu kursorit.

Samuti saab sisestada initsialiseerijate loendi, nagu illustreerib järgmine kood:

vektor<int>vtr{10, kakskümmend, 30, 40};
vektor<int> ::iteraatoriter=vtr.alustada();
++iter;
++iter;
vtr.sisestada(iter, {25, 28});

maksma<<vtr[1] << '' <<vtr[2]<< '
'
<<vtr[3]<< '' <<vtr[4] << ' n';

Väljund on: 20 25 28 30.

kustutamine (positsioon)

Eemaldab elemendi iteraatori osutatud kohast ja tagastab seejärel iteraatori positsiooni. Seda illustreerib järgmine kood:

vektor<int>vtr{10, kakskümmend, 30, 40};
vektor<int> ::iteraatoriter=vtr.alustada();
++iter;
++iter;
vtr.kustutada(iter);
maksma<<vtr[0] << '' <<vtr[1] << '
'
<<vtr[2]<< ' n';

Väljund on: 10 20 40

tagasilöök (t), tagasilöök (rv)

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

vektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};
vtr.lükka tagasi(5.5);
hõljumafl=vtr[4];
maksma<<fl<< ' n';

Väljund on 5,5.

lükka tagasi(rv): -vaata hiljem.

pop_back ()

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

vektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};
vtr.pop_back();
hõljumas=vtr.suurus();
maksma<<s<< ' n';

Väljund on 3.

a. vahetus (b)

Kahte vektorit saab vahetada, nagu on näidatud järgmises koodisegmendis:

vektor<hõljuma>vtr1{1.1, 2.2, 3.3, 4.4};
vektor<hõljuma>vtr2{10, kakskümmend};
vtr1.vahetada(vtr2);
maksma<< 'vtr1:'<<vtr1[0] <<''<<vtr1[1] <<'
'
<<vtr1[2] <<''<<vtr1[3] << ' n';

maksma<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'
<<vtr2[2] <<''<<vtr2[3] << ' n';

Väljund on:

vtr1: 10 kakskümmend 0 0
vtr2: 1.1 2.2 3.3 4.4

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

selge ()

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

vektor<hõljuma>vtr{1.1, 2.2, 3.3, 4.4};
vtr.selge();
maksma<<vtr.suurus() << ' n';

Väljund on 0.

Vektorite võrdõiguslikkuse ja seose operaatorid

== Operaator

Tagastab 1 tõele, kui kaks vektorit on sama suurusega ja vastavad elemendid on võrdsed; vastasel korral tagastab vale väärtuse 0. Näiteks:

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

Väljund on 0.

The! = Operaator

Tagastab 1 väärtuse true, kui kaks vektorit ei ole ühesuurused ja/või vastavad elemendid pole võrdsed; vastasel korral tagastab vale väärtuse 0. Näiteks:

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

Väljund on 1.

The

Tagastab väärtuse 1, kui esimene vektor on teise vektori esialgne alamhulk, kusjuures kahe võrdse osa elemendid on samad ja samas järjekorras. Kui mõlemad vektorid on ühesuurused ja liiguvad vasakult paremale ning esimeses vektoris on element, mis on väiksem kui teise vektori vastav element, tagastatakse ikkagi 1. Vastasel korral tagastatakse vale väärtuse 0. Näiteks:

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

Väljund on 1.

> Operaator

Tagasi! (U

The<= Operator

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

> = Operaator

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

Järeldus

Vektor on jadaümbrise näide. Vektor on tavalise massiivi parem vorm ja see luuakse klassist. Vektoritel on meetodeid, mis on klassifitseeritud järgmiselt: ehitus ja määramine, maht, juurdepääs elementidele, juurdepääs andmetele, iteraatorid, modifikaatorid ja numbrilised ülekoormatud operaatorid.

On ka teisi jadamiskonteinereid, mida nimetatakse loendiks, edasi_loendiks ja massiiviks. Kui ülesanne hõlmab sagedasi sisestusi ja kustutusi jada keskele, siis tuleks kasutada loendit või forward_list. Kui ülesanne hõlmab sagedasi sisestusi ja kustutusi jada alguses või lõpus, tuleks kasutada dekki. Seega tuleks vektoreid kasutada ainult siis, kui sellised toimingud pole olulised.