A C ++ Vector használata

Bevezetés

A tömb ugyanazon objektumtípusok sorozata egymást követő memóriahelyeken. Egy tömb nem növelheti az érc hosszát. A vektor olyan, mint egy tömb, de hossza növelhető vagy csökkenthető. A vektornak tehát sokkal több művelete van, mint egy tömbnek.

A C ++ sok könyvtárral rendelkezik, amelyek mindegyike a C ++ szabványos könyvtárat alkotja. Ezen könyvtárak egyike a konténertár. A tároló objektumok gyűjteménye, és bizonyos műveleteket el lehet végezni a gyűjteményen. A C ++ konténerek két csoportba sorolhatók: szekvencia konténerek és asszociatív konténerek. A szekvencia konténerek a következők: vektor, tömb (nem ugyanaz a tömb, amiről korábban tárgyaltunk), deque, forward_list és list. Ezek különböző gyűjtemények (tömbszerű adatszerkezetek), és mindegyik külön kompromisszumokat kínál.

Bármely programozónak tudnia kell, hogyan kell eldönteni, hogy vektort, tömböt, deque-t, forward_list-ot vagy listát használ-e. Ha egy programozónak olyan struktúrára van szüksége, amely több műveletet igényel, mint a közönséges tömbhöz társított, akkor a közönséges tömböt nem szabad használni.

Ha a feladat gyakori beillesztéseket és törléseket tartalmaz a sorozat közepén, akkor egy listát vagy előre_listát kell használni. Ha a feladat gyakori beillesztéseket és törléseket tartalmaz a sorozat elején vagy végén, akkor deque-ot kell használni. Ha ilyen műveletekre nincs szükség, akkor vektort kell használni.

Ez a cikk bemutatja a C ++ vektor használatát. A cikk megértéséhez szüksége lesz némi ismeretre a C ++ mutatókról, hivatkozásokról és tömbökről.

Osztály és objektumok

Az osztály olyan változók és függvények együttese, amelyek együttesen működnek, ahol a változókhoz nincs hozzárendelve érték. Ha a változókhoz értékeket rendelünk, akkor egy osztály objektummá válik. Ugyanazon osztálynak adott különböző értékek különböző objektumokat eredményeznek; vagyis a különböző objektumok ugyanabba az osztályba tartozhatnak, de eltérő értékekkel rendelkeznek. Objektum létrehozása egy osztályból az objektum példányosításának is nevezik.

A vektor kifejezés leír egy osztályt. A vektorból létrehozott objektumnak van egy neve, amelyet a programozó választ.

Egy osztályhoz tartozó függvényre van szükség egy objektum példányosításához az osztályból. A C ++ nyelven ennek a függvénynek ugyanaz a neve, mint az osztály nevének. Az osztályból létrehozott (példányosított) különböző tárgyaknak külön nevük van, amelyeket mindegyiknek a programozó adott.

Objektum létrehozása osztályból azt jelenti, hogy az objektumot össze kell állítani; ez a tárgy példányosítását is jelenti.

A vektor osztály

A vektorosztály már definiálva van, és a könyvtárban van. A vektorosztály használatához a programozónak be kell építenie a vektor fejlécét a fájlba a következő előfeldolgozási irányelvvel:

#include

A fejléc beillesztése után az összes vektorjellemző (adattagok és tagfunkciók) hozzáférhetővé válik. Ahhoz, hogy a számlálóobjektum adatokat kimenjen a terminálra (konzolra), az objektum fejlécét is be kell illeszteni. A program vektorral történő írásához legalább a következő fejléceket kell tartalmaznia:

#include
#include

Egy vektor beidegzése

int foo [10];

Fent egy tömb deklarációja szerepel a „foo” névvel és a „10.”Ez egy egész tömb. A vektor deklarálása hasonló. Egy vektor esetében az elemek száma nem kötelező, mivel a vektor hossza nőhet vagy csökkenhet.

A program ezen a pontján a vektor osztály már definiálva van a könyvtárban, és a fejléc is benne van. A vektor az alábbiak szerint példányosítható:

std :: vektor vtr (8);

Itt a vektor a speciális konstruktor függvény. A vektor által tárolt adatok típusa „int”, szögletes zárójelben. A „vtr” kifejezés a programozó által a vektor számára választott név. Végül a zárójelben szereplő „8” az a kezdő egész szám, amelyre a vektornak szüksége van.

Az „std” kifejezés a szokásos névteret jelenti. Ezt a kifejezést ebben a kontextusban kettős kettőspontnak kell követnie. Bárki megírhatja saját vektor osztály könyvtárát és használhatja azt. Ugyanakkor a C ++ már rendelkezik egy szabványos könyvtárral, amely szabványos nevekkel rendelkezik, beleértve a „vektort.”A szabványos név használatához a standard név előtt állnia kell: std :: . Annak elkerülése érdekében, hogy az std :: minden alkalommal beírjon egy szabványos nevet a programba, a programfájl a következőképpen indulhat el:

#include
#include
névtér használata std;

Funkció túlterhelése

Ha két vagy több különböző funkció aláírásnak ugyanaz a neve, akkor azt mondják, hogy ez a név túlterhelt. Egy függvény meghívásakor az argumentumok száma és típusa határozza meg, hogy melyik függvényt hajtják végre.

Vektor szerkesztése

A vektor felépítése egy vektorobjektum példányosítását (létrehozását) jelenti. A konstruktor funkció az alábbiak szerint van túlterhelve:

vektor név

Ezzel létrejön egy nulla hosszú és „T” típusú vektor.”A következő utasítás egy„ float ”típusú nulla hosszúságú vektort hoz létre a„ vtr: ”névvel

vektor vtr;

vektor név (n)

Ez egy vektort hoz létre, amelynek n „T” típusú eleme van.”A négy úszó elemmel rendelkező vektor állítása a következő:

vektor vtr (4);

vektor név (n, t)

Ez létrehoz egy n elemből álló vektort, amely inicializálva van a t értékre. A következő utasítás 5 elemből álló vektort hoz létre, ahol minden elemnek 3 az értéke.4:

vektor vtr (5, 3.4);

Konstrukció az inicializálással

Egy vektort egyszerre lehet létrehozni (létrehozni) és inicializálni, a következő két módon:

vektor vtr = 1.1, 2.2, 3.3, 4.4;

Vagy

vektor vtr 1.1, 2.2, 3.3, 4.4;

Vegye figyelembe, hogy az objektum neve után nincsenek zárójelek. Az objektum neve után közvetlenül használt zárójeleknek tartalmazniuk kell az inicializáló listát, az alábbiak szerint:

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

Egy vektor később elkészíthető és inicializálható az inicializáló listával. Ebben az esetben a zárójeleket nem használjuk:

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

vektor V2 (V1)

Ez egy másolatkészítő. V2 vektort hoz létre a V1 vektor másolataként. A következő kód ezt szemlélteti:

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

Vektor hozzárendelése az építkezés során

Az építés során egy üres vektort lehet létrehozni, miközben hozzárendelünk hozzá egy másikat, az alábbiak szerint:

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

A második állítás egyenértékű:

vektor vtr2 = 1.1, 2.2, 3.3, 4.4;

const vektor

A const vektor olyan vektor, amelynek elemeit nem lehet megváltoztatni. A vektor értékei csak olvashatók. Létrehozásakor a vektor a következőképpen jelenik meg:

const vektor vtr 1.1, 2.2, 3.3, 4.4;

Ebben a vektortípusban nem lehet elemet hozzáadni vagy eltávolítani. Sőt, semmilyen érték nem változtatható meg.

Konstrukció az Iteratorral

A sablon általános ábrázolást ad az adattípushoz. Az iterátor egy reprezentatív reprezentációt nyújt a beolvasáshoz egy tároló értékein keresztül. Az iterátorral létrehozott vektor szintaxisa a következő:

sablon
vektor (InputIterator először, InputIterator utolsó, const Allocator & = Allocator ());

Ez létrehoz egy vektort az [első, utolsó) tartományhoz a megadott allokátor segítségével, amelyet később a cikkben tárgyalunk.

Egy vektor megsemmisítése

A vektor megsemmisítéséhez egyszerűen engedje meg, hogy kilépjen a hatókörből, és a megsemmisítést automatikusan kezeljük.

Vektor kapacitás

size_type kapacitás () const noexcept

A kapacitás-tag függvény visszaadja azon elemek teljes számát, amelyeket a vektor megtarthat anélkül, hogy újra kellene osztani őket. Ennek kódszegmense a következő:

vektor vtr (4);
int szám = vtr.kapacitás();
cout << num << '\n';

A kimenet 4.

tartalék (n)

A memóriaterület nem mindig érhető el szabadon. Extra hely előre lefoglalható. Vegye figyelembe a következő kódszegmenst:

vektor vtr (4);
vtr.tartalék (6);
cout << vtr.capacity() << '\n';

A kimenet 6. Tehát a fenntartott extra hely 6 - 4 = 2 elem. A függvény érvénytelen.

size () const noexcept

Ez visszaadja a vektor elemeinek számát. A következő kód szemlélteti ezt a funkciót:

vektor vtr (4);
úszó sz = vtr.méret();
cout << sz << '\n';

A kimenet 4.

shrink_to_fit ()

Miután extra kapacitást adott egy vektornak a reserve () függvénnyel, a vektor lefelé méretezhető, hogy illeszkedjen az eredeti méretéhez. A következő kód ezt szemlélteti:

vektor vtr (4);
vtr.tartalék (6);
vtr.shrink_to_fit ();
int sz = vtr.méret();
cout << sz << '\n';

A kimenet 4 és nem 6. A függvény érvénytelen.

átméretezés (sz), átméretezés (sz, c)

Ez átméretezi a vektort. Ha az új méret kisebb, mint a régi méret, akkor a végén lévő elemek törlődnek. Ha az új méret hosszabb, akkor a vége felé néhány alapértelmezett értéket adunk hozzá. Egy adott hozzáadott érték eléréséhez használja a resize () függvényt két argumentummal. Az alábbi kódszegmens szemlélteti e két funkció használatát:

vektor vtr1 1.1, 2.2, 3.3, 4.4;
vtr1.átméretezés (2);
cout << "New size of vtr1: " << vtr1.size() << '\n';
vektor vtr2 1.1, 2.2;
vtr2.átméretezés (4, 8.8.);
cout << "vtr2: "<< vtr2[0] <<" "<< vtr2[1] <<"
"<< vtr2[2] <<" "<< vtr2[3] << '\n';

A kimenet a következő:

Új méretű vtr1: 2
vtr2: 1.1 2.2 8.8 8.8

A funkciók érvénytelenek.

üres () const noexcept

Ez a függvény 1-t ad vissza true értékre, ha nincs elem a vektorban, és 0-t hamis értékre, ha a vektor üres. Ha egy vektornak 4 helye van egy adott típusú adathoz, például úszóhoz, úszóérték nélkül, akkor az a vektor nem üres. A következő kód ezt szemlélteti:

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

A kimenet a következő:

1
0
0

Vektor elem hozzáférés

A vektorok tömbhöz hasonlóan szkriptelhetők (indexelhetők). Az indexszámlálás nullától kezdődik.

vectorName [i]

A „vectorName [i]” művelet hivatkozást ad az i-ben lévő elemre^th a vektor indexe. A következő kódkimenetek 3.3 a fenti vektorhoz:

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

vectorName [i] const

A „vectorName [i] const” műveletet a „vectorName [i]” helyett hajtjuk végre, ha a vektor állandó vektor. Ezt a műveletet a következő kódban használják:

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

A kifejezés állandó hivatkozást ad vissza az i-re^th a vektor eleme.

Érték hozzárendelése Subscript-hez

Egy érték nem állandó vektorhoz rendelhető az alábbiak szerint:

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

A kimenet 8.8.

vectorName.az i) pontnál

„VectorName.az (i) -nél ”olyan, mint a„ vectorName [i] ”, de a„ vectorName ”.az (i) pontnál ”megbízhatóbb. A következő kód megmutatja, hogy ezt a vektort hogyan kell használni:

vektor vtr 1.1, 2.2, 3.3, 4.4;
úszó fl = vtr.a (2) -nél;
cout << fl << '\n';
at () egy vektor tag függvény.

vectorName.az (i) konst

„VectorName.az (i) const-nál "olyan, mint a" vectorName [i] const ", de a" vectorName ".az (i) const-nál ”megbízhatóbb. „VectorName.at (i) const ”a„ vectorName ”helyett kerül végrehajtásra.az (i) pontnál ”, amikor a vektor állandó vektor. Ezt a vektort a következő kódban használják:

const vektor vtr 1.1, 2.2, 3.3, 4.4;
úszó fl = vtr.a (2) -nél;
cout << fl << '\n';
az () const egy vektortagfüggvény.

Érték hozzárendelése az at () függvénnyel

Egy nem konstans vektorhoz az at () függvénnyel lehet értéket rendelni az alábbiak szerint:

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

A kimenet 8.8.

Probléma az alszkriptekkel

Az alszkripteléssel (indexeléssel) az a probléma, hogy ha az index a tartományon kívül esik, nullát adhatunk vissza, vagy hibát adhatunk ki futás közben.

elülső()

Ez egy hivatkozást ad vissza a vektor első elemére anélkül, hogy eltávolítaná az elemet. A következő kód kimenete 1.1.

vektor vtr 1.1, 2.2, 3.3, 4.4;
úszó fl = vtr.elülső();
cout << fl << '\n';

Az elem nem kerül eltávolításra a vektorból.

elülső () konst

Ha a vektor felépítését const előzi meg, akkor a „front () const” kifejezés kerül végrehajtásra a „front () helyett.”Ezt a következő kódban használják:

const vektor vtr 1.1, 2.2, 3.3, 4.4;
úszó fl = vtr.elülső();
cout << fl << '\n';

Egy állandó referenciát adunk vissza. Az elem nem kerül eltávolításra a vektorból.

vissza()

Ez visszaadja a hivatkozást a vektor utolsó elemére anélkül, hogy eltávolítaná az elemet. A következő kód kimenete 4.4.

vektor vtr 1.1, 2.2, 3.3, 4.4;
úszó fl = vtr.vissza();
cout << fl << '\n';

vissza () konst

Ha a vektor felépítését const előzi meg, akkor a „back () const” kifejezés kerül végrehajtásra a „back () helyett.”Ezt a következő kódban használják:

const vektor vtr 1.1, 2.2, 3.3, 4.4;
úszó fl = vtr.vissza();
cout << fl << '\n';

Egy állandó referenciát adunk vissza. Az elem nem kerül eltávolításra a vektorból.

Vektoros adatelérés

adatok () noexcept; data () const noexcept;

Ezek bármelyike olyan mutatót ad vissza, hogy az [adatok (), adatok () + méret ()] érvényes tartomány.

Erről a cikk későbbi részében lesz szó.

Visszatérő iterátorok és a vektor

Az iterátor olyan, mint egy mutató, de több funkcióval rendelkezik, mint egy mutató.

kezdődik () noexcept

Visszaad egy iterátort, amely a vektor első elemére mutat, a következő kódszegmenshez hasonlóan:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vektor:: iterátor iter = vtr.kezdődik();
cout << *iter << '\n';

A kimenet 1.1. Vegye figyelembe, hogy az iterátort fogadó deklarációt deklarálták. Az iterátor egy visszatérési kifejezésben kerül levezetésre, hogy az értéket ugyanúgy megszerezze, mint egy mutatót.

begin () const noexcept;

Visszaad egy iterátort, amely a vektor első elemére mutat. Amikor a vektorkonstrukciót megelőzi a const, a „begin () const” kifejezés kerül végrehajtásra a „begin () helyett.”Ilyen feltétel mellett a vektor megfelelő eleme nem módosítható. Ezt a következő kódban használják:

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

A kimenet 1.1. Ne feledje, hogy a visszatérő iterátor fogadásához ezúttal a „const_iterator” szót használták az „iterator” helyett.

end () noexcept

Olyan iterátort ad vissza, amely közvetlenül a vektor utolsó elemén túlmutat. Vegye figyelembe a következő kódszegmenst:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vektor:: iterátor iter = vtr.vége ();
cout << *iter << '\n';

A kimenet 0, ami értelmetlen, mivel az utolsó elemen túl nincs konkrét elem.

end () const noexcept

Olyan iterátort ad vissza, amely közvetlenül a vektor utolsó elemén túlmutat. Ha a vektor felépítését „const” előzi meg, akkor a „end () const” kifejezés kerül végrehajtásra."Vegye figyelembe a következő kódszegmenst:

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

A kimenet 0. Ne feledje, hogy a visszatérő iterátor fogadásához ezúttal a „const_iterator” szót használták az „iterator” helyett.

Fordított iteráció

Lehetséges olyan iterátor, amely a végétől az első elemig közvetlenül ismétlődik.

rbegin () noexcept

Visszaad egy iterátort, amely a vektor utolsó elemére mutat, a következő kódszegmenshez hasonlóan:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vektor:: fordított_iterátor rIter = vtr.rbegin ();
cout << *rIter << '\n';

A kimenet 4.4.

Ne feledje, hogy azt a deklarációt deklarálták, amely a fordított iterátort kapja. Az iterátor egy visszatérési kifejezésben kerül levezetésre, hogy az értéket ugyanúgy megszerezze, mint egy mutatót.

rbegin () const noexcept;

Visszaad egy iterátort, amely a vektor utolsó elemére mutat. Amikor a vektor felépítését „const” előzi meg, akkor az „rbegin () helyett az„ rbegin () const ”kifejezés kerül végrehajtásra.”Ilyen feltétel mellett a vektor megfelelő eleme nem módosítható. Ez a szolgáltatás a következő kódban használható:

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

A kimenet 4.4.

Ne feledje, hogy a const_reverse_iterator-t ezúttal a fordított_iterator helyett használták a visszaadott iterátor fogadására.

rend () noexcept

Visszaad egy iterátort, amely közvetlenül a vektor első eleme előtt mutat. Vegye figyelembe a következő kódszegmenst:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vektor:: fordított_iterátor rIter = vtr.rend ();
cout << *rIter << '\n';

A kimenet 0, ami értelmetlen, mivel közvetlenül az első elem előtt nincs konkrét elem.

rend () const noexcept

Visszaad egy iterátort, amely közvetlenül a vektor első eleme előtt mutat. Amikor a vektor felépítését „const” előzi meg, a „rend ()” helyett a „rend () const” kifejezés kerül végrehajtásra."Vegye figyelembe a következő kódszegmenst:

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

A kimenet 0.

Ne feledje, hogy a const_reverse_iterator-t ezúttal a fordított_iterator helyett használták a visszaadott iterátor fogadására.

Vektor módosítók

A vektort módosító módosító iterátort vehet fel vagy adhat vissza.

a.munkahely (p, arg)

Beszúr egy T típusú objektumot, amely az std :: forward paranccsal készült(érvel)… o. előtt.

Részletek - lásd később

beszúrás (iteratorPosition, érték)

Beszúrja az érték egy példányát a vektor iterátor pozíciójába. Visszaadja az iterátort (pozíciót) abban a vektorban, ahová a másolatot helyezték. A következő kód megmutatja, hogy az érték hova került:

vektor vtr 10, 20, 30, 40;
vektor:: iterátor iter = vtr.kezdődik();
++iter;
++iter;
vtr.betét (iter, 25);
cout << vtr[1] << " << vtr[2]<< '
" << vtr[3] << '\n';

A kimenet: 20 25 30.

Ne feledje, hogy az iterátor fejlett volt (növekményes), mint egy mutató.

Inicializáló lista is beilleszthető, mivel a következő kód szemlélteti:

vektor vtr 10, 20, 30, 40;
vektor:: iterátor iter = vtr.kezdődik();
++iter;
++iter;
vtr.beszúrás (iter, 25, 28);
cout << vtr[1] << " << vtr[2]<< '
" << vtr[3]<< " << vtr[4] << '\n';

A kimenet: 20 25 28 30.

törlés (pozíció)

Eltávolít egy elemet az iterátor által mutatott helyzetben, majd visszaadja az iterátor pozícióját. A következő kód ezt szemlélteti:

vektor vtr 10, 20, 30, 40;
vektor:: iterátor iter = vtr.kezdődik();
++iter;
++iter;
vtr.törlés (iter);
cout << vtr[0] << " << vtr[1] << '
" << vtr[2]<< '\n';

A kimenet: 10 20 40

push_back (t), push_back (rv)

Egyetlen elem hozzáadására szolgál a vektor végén. Használja a push_back (t) elemet az alábbiak szerint:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vtr.visszalépés (5.5);
úszó fl = vtr [4];
cout << fl << '\n';

A kimenet 5.5.

push_back (rv): - lásd később.

pop_back ()

Eltávolítja az utolsó elemet anélkül, hogy visszaküldené. A vektor méretét 1-gyel csökkentjük. A következő kód ezt szemlélteti:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vtr.pop_back ();
úszó sz = vtr.méret();
cout << sz << '\n';

A kimenet 3.

a.csere (b)

Két vektor felcserélhető, amint azt a következő kódszegmens szemlélteti:

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

A kimenet:

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

Ne feledje, hogy a vektor hossza megnő, ha szükséges. Ezenkívül azokat az értékeket, amelyek nem voltak helyettesítők, valamilyen alapértelmezett érték váltja fel.

egyértelmű()

Eltávolít minden elemet a vektorból, ahogy a következő kódszegmens szemlélteti:

vektor vtr 1.1, 2.2, 3.3, 4.4;
vtr.egyértelmű();
cout << vtr.size() << '\n';

A kimenet 0.

Egyenlőség és kapcsolati operátorok a vektorok számára

A == Operátor

1 értéket ad vissza true értékre, ha a két vektor azonos méretű és a megfelelő elemek egyenlőek; ellenkező esetben 0-t ad vissza hamis értékre. Például:

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

A kimenet 0.

A != Operátor

1 értéket ad vissza true értékre, ha a két vektor nem azonos méretű és / vagy a megfelelő elemek nem egyenlőek; ellenkező esetben 0-t ad vissza hamis értékre. Például:

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

A kimenet 1.

A < Operator

1 értéket ad vissza true értékre, ha az első vektor a második vektor kezdeti részhalmaza, a két egyenlő rész elemei azonosak és ugyanabban a sorrendben. Ha mindkét vektor azonos méretű és balról jobbra mozog, és az első vektorban olyan elem találkozik, amely kisebb, mint a második vektor megfelelő eleme, akkor az 1 akkor is visszatér. Ellenkező esetben a hamis 0 értéket adja vissza. Például:

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

A kimenet 1. < does not include the case when the size and order are the same.

Az> Operátor

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

A <= Operator

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

A> = Operátor

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

Következtetés

A vektor egy példa egy szekvenciatartályra. A vektor a közönséges tömb „jobb” formája, és egy osztályból példányos. A vektoroknak módszerei vannak, amelyek a következők szerint vannak besorolva: felépítés és hozzárendelés, kapacitás, elemhez való hozzáférés, adatelérés, iterátorok, módosítók és numerikusan túlterhelt operátorok.

Vannak más szekvenciatárolók is, úgynevezett list, forward_list és tömb. Ha a feladat gyakori beillesztéseket és törléseket tartalmaz a sorozat közepén, akkor egy listát vagy előre_listát kell használni. Ha a feladat gyakori beillesztéseket és törléseket tartalmaz a sorozat elején vagy végén, akkor deque-ot kell használni. Ezért a vektorokat csak akkor szabad használni, ha az ilyen típusú műveletek nem fontosak.