Bevezetés
A tömb azonos objektumtípusok sorozata egymást követő memóriahelyeken. Egy tömb nem növelheti az érc hosszának csökkentését. A vektor olyan, mint egy tömb, de hossza növelhető vagy csökkenthető. Ezért egy vektornak sokkal több művelete van, mint egy tömbnek.
A C ++ számos könyvtárral rendelkezik, amelyek mindegyike a C ++ szabványos könyvtárat alkotja. Az egyik ilyen könyvtár a tárolókönyvtár. A tároló objektumok gyűjteménye, és bizonyos műveletek végrehajthatók a gyűjteményen. A C ++ tárolók két csoportba sorolhatók: szekvenciatartályok és asszociatív tárolók. A szekvencia tárolók a vektor, tömb (nem ugyanaz a tömb, amelyet korábban tárgyaltunk), deque, forward_list és list. Ezek különböző gyűjtemények (tömbszerű adatstruktúrák), és mindegyik egyedi kompromisszumokat kínál.
Minden programozónak tudnia kell, hogyan kell eldönteni, hogy vektort, tömböt, dekort, forward_list 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 rendes tömbhöz tartozó, akkor a szokásos tömböt nem szabad használni.
Ha a feladat gyakori beszúrásokat és törléseket tartalmaz a sorozat közepén, akkor listát vagy forward_list -et kell használni. Ha a feladat gyakori beszúrásokat és törléseket tartalmaz a sorozat elejére vagy végére, akkor dekket kell használni. Vektort kell használni, ha az ilyen típusú műveletekre nincs szükség.
Ez a cikk bemutatja a C ++ vektor használatát. A cikk megértéséhez szüksége lesz némi C ++ mutató, referencia és tömb ismeretére.
Osztály és tárgyak
Az osztály olyan változók és függvények együttese, amelyek együtt működnek, és ahol a változókhoz nincsenek hozzárendelve értékek. Ha értékeket rendelünk a változókhoz, egy osztály objektummá válik. Az azonos 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. Az objektum osztályból való létrehozását más néven az objektum példányosításának is nevezik.
A vektor kifejezés egy osztályt ír le. A vektorból létrehozott objektumnak a programozó által kiválasztott neve van.
Egy osztályhoz tartozó függvényre van szükség az objektum osztályból való kivonásához. C ++ - ban ez a függvény ugyanazzal a névvel rendelkezik, mint az osztály neve. Az osztályból létrehozott (példányosított) különböző objektumoknak külön neve van, amelyeket a programozó mindegyiküknek adott.
Egy objektum osztályból való létrehozása az objektum felépítését jelenti; az objektum példányosítását is jelenti.
A vektoros 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 vennie a vektorfejlécet a fájlba a következő előfeldolgozási irányelvvel:
#befoglalniA fejléc beillesztése után az összes vektorjellemző (adattagok és tagfüggvények) elérhetővé válik. Ahhoz, hogy a számlálóobjektum segítségével adatokat küldhessen a terminálhoz (konzolhoz), az objektum fejlécét is tartalmaznia kell. Ha programot szeretne írni a vektorral, legalább a következő fejléceket kell tartalmaznia:
#befoglalni#befoglalni
Vektor beiktatása
intfoo[10];A fenti a foo nevű tömb deklarációja és a 10. elemek száma. Ez egy egész számok tömbje. A vektor deklarálása hasonló. Egy vektor esetében az elemek száma nem kötelező, mivel a vektor hossza növekedhet vagy csökkenhet.
A program ezen a pontján a vektorosztály már definiálva volt a könyvtárban, és a fejléc bekerült. A vektor a következőképpen példázható:
órák::vektor <int>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 vektorhoz választott név. Végül 8, zárójelben, a vektort érintő egész számok előzetes száma.
Az std kifejezés a szabványos névteret jelenti. Ezt a kifejezést ebben az összefüggésben kettős kettőspontnak kell követnie. Bárki megírhatja saját vektoros osztálykönyvtárát és használhatja azt. A C ++ azonban már rendelkezik szabványos könyvtárral, standard nevekkel, beleértve a vektort is. A szabványos név használatához a szabványnevet std :: elé kell írni. Annak elkerülése érdekében, hogy a szabványos nevű programban minden alkalommal beírja az std :: parancsot, a programfájl a következőképpen indulhat el:
#befoglalni#befoglalni
névtér standard használatával;
Egy funkció túlterhelése
Ha két vagy több különböző funkció -aláírás azonos névvel rendelkezik, akkor 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ény kerül végrehajtásra.
Vektor készítése
A vektor felépítése vektorobjektum példányosítását (létrehozását) jelenti. A konstruktor funkció a következőképpen van túlterhelve:
vektor neve
Ez létrehozza a nulla hosszúságú és T típusú vektort. A következő utasítás létrehoz egy nulla hosszúságú vektort a float típusú vtr névvel:
vektor<úszó>vtr;vektor neve (n)
Ez létrehoz egy vektort n T típusú T elemmel. A négy úszóelemmel rendelkező vektorra vonatkozó utasítás a következő:
vektor<úszó>vtr(4);vektor neve (n, t)
Ezzel létrejön egy n elemből álló vektor, amely a t értékre van inicializálva. Az alábbi utasítás 5 elemből álló vektort hoz létre, ahol minden elem 3,4 értékű:
vektor<úszó>vtr(5, 3.4);Építés inicializálással
Egy vektort egyszerre lehet létrehozni (létrehozni) és inicializálni, az alábbi két módszer egyikével:
vektor<úszó>vtr= {1.1, 2.2, 3.3, 4.4};Vagy
vektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};Ne feledje, hogy nincs zárójel csak az objektum neve után. Az éppen az objektumnév után használt zárójeleknek tartalmazniuk kell az inicializáló listát, az alábbiak szerint:
vektor<úszó>vtr({1.1, 2.2, 3.3, 4.4});Egy vektor szerkeszthető és inicializálható később az inicializáló listával. Ebben az esetben a zárójelek nem használhatók:
vektor<úszó>vtr;vtr= {1.1, 2.2, 3.3, 4.4};
V2 vektor (V1)
Ez egy másolat készítő. V2 vektort hoz létre a V1 vektor másolataként. A következő kód ezt szemlélteti:
vektor<úszó>vtr1(5, 3.4);vektor<úszó>vtr2(vtr1);
Vektor hozzárendelése az építés során
Az építés során egy üres vektor hozható létre, míg egy másik hozzá van rendelve, az alábbiak szerint:
vektor<úszó>vtr1{1.1, 2.2, 3.3, 4.4};vektor<úszó>vtr2=vtr1;
A második állítás egyenértékű:
vektor<úszó>vtr2= {1.1, 2.2, 3.3, 4.4};const Vektor
A const vektor olyan vektor, amelynek elemei nem változtathatók meg. A vektor értékei csak olvashatóak. Létrehozásakor a vektor a következőképpen jelenik meg:
constvektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};Ebben a vektor típusban egyetlen elem sem adható hozzá vagy távolítható el. Ezenkívül semmilyen érték nem változtatható meg.
Építés Iterator segítségével
A sablon általános ábrázolást biztosít az adattípus számára. Az iterátor általános ábrázolást biztosít a tároló értékei közötti szkenneléshez. Az iterátoros vektor létrehozásának szintaxisa a következő:
sablon<osztályú InputIterator>vektor(InputIterator először,InputIterator utolsó,constAllokátor& =Allokátor());
Ez létrehoz egy vektort az [első, utolsó] tartományhoz a megadott allokátor segítségével, amelyet a cikk későbbi részében tárgyalunk.
A vektor megsemmisítése
A vektor megsemmisítéséhez egyszerűen hagyja, hogy kimegy a hatókörből, és a megsemmisítés automatikusan történik.
Vektoros kapacitás
size_type capacity () const noexcept
A kapacitástag függvény visszaadja a vektor által az elemek teljes számát anélkül, hogy újraelosztást igényelne. Ennek kódszegmense a következő:
vektor<úszó>vtr(4);intaz egyiken=vtr.kapacitás();
költség<<az egyiken<< ' n';
A kimenet 4.
tartalék (n)
A memória nem mindig szabadon elérhető. További helyek előre foglalhatók. Tekintsük a következő kódrészletet:
vektor<úszó>vtr(4);vtr.lefoglal(6);
költség<<vtr.kapacitás() << ' n';
A kimenet 6. Tehát a lefoglalt extra hely 6 - 4 = 2 elem. A függvény üreset ad vissza.
size () const noexcept
Ez a vektor elemeinek számát adja vissza. A következő kód illusztrálja ezt a funkciót:
vektor<úszó>vtr(4);úszósz=vtr.méret();
költség<<sz<< ' n';
A kimenet 4.
shrink_to_fit ()
Miután a tartalék () funkcióval rendelkező vektornak extra kapacitást biztosított, a vektor méretezhető le, hogy illeszkedjen az eredeti méretéhez. A következő kód ezt szemlélteti:
vektor<úszó>vtr(4);vtr.lefoglal(6);
vtr.zsugorodni_illeszkedni();
intsz=vtr.méret();
költség<<sz<< ' n';
A kimenet 4 és nem 6. A függvény void értéket ad vissza.
átméretezés (sz), átméretezés (sz, c)
Ez átméretezi a vektort. Ha az új méret kisebb, mint a régi, akkor a vége felé lévő elemek törlődnek. Ha az új méret hosszabb, akkor a vége felé némi alapértelmezett érték kerül hozzáadásra. Egy adott hozzáadott érték eléréséhez használja a resize () függvényt két argumentummal. A következő kódrészlet e két funkció használatát szemlélteti:
vektor<úszó>vtr1{1.1, 2.2, 3.3, 4.4};vtr1.átméretezni(2);
költség<< 'A vtr1 új mérete:' <<vtr1.méret() << ' n';
vektor<úszó>vtr2{1.1, 2.2};
vtr2.átméretezni(4, 8.8);
költség<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'<<vtr2[2] <<''<<vtr2[3] << ' n';
A kimenet a következő:
A vtr1: 2 új méretevtr2: 1.1 2.2 8.8 8.8
A függvények üresen térnek vissza.
empty () const noexcept
Ez a függvény 1 -et ad vissza igaz értékre, ha nincsenek elemek a vektorban, és 0 -t hamis értékre, ha a vektor üres. Ha egy vektornak 4 helye van egy bizonyos típusú adathoz, például lebegő, lebegési érték nélkül, akkor ez a vektor nem üres. A következő kód ezt szemlélteti:
vektor<úszó>vtr;költség<<vtr.üres() << ' n';
vektor<úszó>vt(4);
költség<<hát aztüres() << ' n';
vektor<úszó>v(4,3.5);
költség<<v.üres() << ' n';
A kimenet a következő:
10
0
Vektoros elemek elérése
A vektort szkriptként (indexelve) lehet tömbhöz hasonlóan. Az indexszámlálás nulláról indul.
vectorName [i]
A vectorName [i] művelet egy hivatkozást ad vissza az i -nél lévő elemretha vektor indexe. A fenti kód kimenetei 3.3 a fenti vektorhoz:
vektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};úszófl=vtr[2];
költség<<fl<< ' n';
vectorName [i] const
A vectorName [i] const műveletet a vektorName [i] helyett hajtjuk végre, ha a vektor állandó vektor. Ezt a műveletet a következő kódban használják:
constvektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};úszófl=vtr[2];
költség<<fl<< ' n';
A kifejezés állandó hivatkozást ad vissza az i -retha vektor eleme.
Érték hozzárendelése az indexhez
Egy érték nem állandó vektorhoz rendelhető, az alábbiak szerint:
vektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};vtr[2] = 8.8;
költség<<vtr[2] << ' n';
A kimenet 8,8.
vectorName.at (i)
vectorName.at (i) olyan, mint a vectorName [i], de a vectorName.at (i) megbízhatóbb. A következő kód megmutatja, hogyan kell ezt a vektort használni:
vektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};úszófl=vtr.nál nél(2);
költség<<fl<< ' n';
nál nél()vektor tagjafunkció.
vectorName.at (i) const
vectorName.at (i) const olyan, mint a vectorName [i] const, de a vectorName.at (i) const megbízhatóbb. vectorName.at (i) const hajtódik végre a vectorName.at (i) helyett, ha a vektor állandó vektor. Ezt a vektort a következő kódban használják:
constvektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};úszófl=vtr.nál nél(2);
költség<<fl<< ' n';
nál nél() constvektor tagjafunkció.
Érték hozzárendelése az at () függvénnyel
Egy értéket nem konstans vektorhoz rendelhetünk az at () függvénnyel, az alábbiak szerint:
vektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};vtr.nál nél(2) = 8.8;
költség<<vtr[2] << ' n';
A kimenet 8,8.
Probléma a szkripteléssel
Az al-szkripteléssel (indexeléssel) az a probléma, hogy ha az index a tartományon kívül esik, akkor a nulla visszaadható, vagy futás közben hiba léphet fel.
elülső()
Ez a vektor első elemére való hivatkozást adja vissza az elem eltávolítása nélkül. A következő kód kimenete 1.1.
vektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};úszófl=vtr.elülső();
költség<<fl<< ' n';
Az elem nincs eltávolítva a vektorból.
front () const
Ha a vektor konstrukciót a 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:
constvektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};úszófl=vtr.elülső();
költség<<fl<< ' n';
Az állandó hivatkozás visszatér. Az elem nincs eltávolítva a vektorból.
vissza()
Ez a vektor utolsó elemére való hivatkozást adja vissza az elem eltávolítása nélkül. A következő kód kimenete: 4.4.
vektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};úszófl=vtr.vissza();
költség<<fl<< ' n';
vissza () const
Ha a vektor konstrukciót a 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:
constvektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};úszófl=vtr.vissza();
költség<<fl<< ' n';
Az állandó hivatkozás visszatér. Az elem nincs eltávolítva a vektorból.
Vektoros adathozzáférés
data () noexcept; data () const noexcept;
Ezek bármelyike olyan mutatót ad vissza, amely [data (), data () + size ()] érvényes tartomány.
Erről részletesebben lesz szó a cikk későbbi részében.
Visszatérő iterátorok és a vektor
Az iterátor olyan, mint egy mutató, de több funkcióval rendelkezik, mint egy mutató.
start () noexcept
Visszaad egy iterátort, amely a vektor első elemére mutat, a következő kódszegmensben:
vektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};vektor<úszó> ::iterátoriter=vtr.kezdődik();
költség<< *iter<< ' n';
A kimenet 1.1. Vegye figyelembe, hogy az iterátort fogadó nyilatkozat deklarálva van. Az iterátor visszavonja a visszatérési kifejezést, hogy ugyanúgy megkapja az értéket, mint a mutató.
begin () const noexcept;
Visszaad egy iterátort, amely a vektor első elemére mutat. Ha a vektor konstrukciót a const előzi meg, akkor a begin () const kifejezést hajtjuk végre a begin () helyett. Ilyen körülmények között a vektor megfelelő eleme nem módosítható. Ezt a következő kódban használják:
constvektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};vektor<úszó> ::const_iteratoriter=vtr.kezdődik();
költség<< *iter<< ' n';
A kimenet 1.1. Ne feledje, hogy a const_iterator -t ezúttal nem az iterátor helyett használták a visszaadott iterátor fogadására.
end () noexcept
Visszaad egy iterátort, amely közvetlenül a vektor utolsó elemén túlmutat. Tekintsük a következő kódrészletet:
vektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};vektor<úszó> ::iterátoriter=vtr.vége();
költség<< *iter<< ' n';
A kimenet 0, ami értelmetlen, mivel az utolsó elemen túl nincs konkrét elem.
end () const noexcept
Visszaad egy iterátort, amely közvetlenül a vektor utolsó elemén túlmutat. Ha a vektor konstrukciót a const előzi meg, akkor az end () const kifejezést hajtjuk végre a end () helyett. Tekintsük a következő kódrészletet:
constvektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};vektor<úszó> ::const_iteratoriter=vtr.vége();
költség<< *iter<< ' n';
A kimenet 0. Vegye figyelembe, hogy a const_iterator -t ezúttal az iterátor helyett használták a visszaadott iterátor fogadására.
Fordított iteráció
Lehetséges olyan iterátor, amely a végétől az első elemig ismétlődik.
rbegin () noexcept
Visszaad egy iterátort, amely a vektor utolsó elemére mutat, a következő kódszegmensben:
vektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};vektor<úszó> ::reverse_iteratorrIter=vtr.rbegin();
költség<< *rIter<< ' n';
A kimenet 4,4.
Ne feledje, hogy a fordított iterátort fogadó nyilatkozat deklarálva van. Az iterátor visszavonja a visszatérési kifejezést, hogy ugyanúgy megkapja az értéket, mint a mutató.
rbegin () const noexcept;
Visszaad egy iterátort, amely a vektor utolsó elemére mutat. Ha a vektor konstrukciót a const előzi meg, akkor az rbegin () const kifejezést hajtjuk végre az rbegin () helyett. Ilyen körülmények között a vektor megfelelő eleme nem módosítható. Ezt a funkciót a következő kódban használják:
constvektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};vektor<úszó> ::const_reverse_iteratorrIter=vtr.rbegin();
költség<< *rIter<< ' n';
A kimenet 4,4.
Ne feledje, hogy a const_reverse_iterator ezúttal a reverse_iterator helyett a visszaadott iterátor fogadására szolgál.
render () noexcept
Egy iterátort ad vissza, amely közvetlenül a vektor első eleme előtt mutat. Tekintsük a következő kódrészletet:
vektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};vektor<úszó> ::reverse_iteratorrIter=vtr.teszi();
költség<< *rIter<< ' n';
A kimenet 0, ami értelmetlen, mivel nincs konkrét elem közvetlenül az első elem előtt.
render () const noexcept
Egy iterátort ad vissza, amely közvetlenül a vektor első eleme előtt mutat. Ha a vektor konstrukciót a const előzi meg, akkor a rend () const kifejezés kerül végrehajtásra a rend () helyett. Tekintsük a következő kódrészletet:
constvektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};vektor<úszó> ::const_reverse_iteratorrIter=vtr.teszi();
költség<< *rIter<< ' n';
A kimenet 0.
Ne feledje, hogy a const_reverse_iterator ezúttal a reverse_iterator helyett a visszaadott iterátor fogadására szolgál.
Vektor módosítók
A vektort módosító módosító iterátort vehet fel vagy adhat vissza.
a. implace (p, args)
Beszúr egy T típusú objektumot, amelyet std :: forward (args)… -al konstruáltak.
Részletekért - lásd későbbbeszúrás (iteratorPosition, value)
Beilleszti az érték másolatát a vektor iterátor pozíciójába. Visszaadja az iterátort (pozíciót) abban a vektorban, ahová a másolatot elhelyezték. A következő kód azt mutatja, hogy az értéket hol helyezték el:
vektor<int>vtr{10, húsz, 30, 40};vektor<int> ::iterátoriter=vtr.kezdődik();
++iter;
++iter;
vtr.betét(iter, 25);
költség<<vtr[1] << '' <<vtr[2]<< '
' <<vtr[3] << ' n';
A kimenet: 20 25 30.
Ne feledje, hogy az iterátor előrehaladott (növekvő), mint egy mutató.
Egy inicializáló lista is beszúrható, amint azt a következő kód szemlélteti:
vektor<int>vtr{10, húsz, 30, 40};vektor<int> ::iterátoriter=vtr.kezdődik();
++iter;
++iter;
vtr.betét(iter, {25, 28});
költség<<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 jelzett pozícióból, majd visszaadja az iterátor pozícióját. A következő kód ezt szemlélteti:
vektor<int>vtr{10, húsz, 30, 40};vektor<int> ::iterátoriter=vtr.kezdődik();
++iter;
++iter;
vtr.törli(iter);
költség<<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ére. Használja a push_back (t) -t az alábbiak szerint:
vektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};vtr.visszavet(5.5);
úszófl=vtr[4];
költség<<fl<< ' n';
A kimenet 5,5.
visszavet(rv): -Viszlát.pop_back ()
Eltávolítja az utolsó elemet anélkül, hogy visszaadná. A vektor mérete 1 -gyel csökken. A következő kód illusztrálja ezt:
vektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};vtr.pop_back();
úszósz=vtr.méret();
költség<<sz<< ' n';
A kimenet 3.
a. csere (b)
Két vektor cserélhető, amint azt a következő kódrészlet mutatja:
vektor<úszó>vtr1{1.1, 2.2, 3.3, 4.4};vektor<úszó>vtr2{10, húsz};
vtr1.csere(vtr2);
költség<< 'vtr1:'<<vtr1[0] <<''<<vtr1[1] <<'
'<<vtr1[2] <<''<<vtr1[3] << ' n';
költség<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'<<vtr2[2] <<''<<vtr2[3] << ' n';
A kimenet:
vtr1: 10 húsz 0 0vtr2: 1.1 2.2 3.3 4.4
Vegye figyelembe, hogy a vektor hossza szükség esetén megnő. Ezenkívül azokat az értékeket, amelyek nem tartalmaztak cserét, valamilyen alapértelmezett érték váltja fel.
egyértelmű()
Eltávolítja az összes elemet a vektorból, amint azt a következő kódrészlet illusztrálja:
vektor<úszó>vtr{1.1, 2.2, 3.3, 4.4};vtr.egyértelmű();
költség<<vtr.méret() << ' n';
A kimenet 0.
Egyenlőségi és relációs operátorok a vektorokhoz
A == operátor
1 értéket ad vissza, ha a két vektor azonos méretű, és a megfelelő elemek egyenlők; ellenkező esetben 0 -t ad vissza hamis értékre. Például:
vektor<int>U{1, 2, 3};vektor<int>V{4, 5, 6};
bool bl=U==V;
költség<<bl<< ' n';
A kimenet 0.
A! = Kezelő
1 értéket ad vissza, ha a két vektor nem azonos méretű és/vagy a megfelelő elemek nem egyenlők; ellenkező esetben 0 -t ad vissza hamis értékre. Például:
vektor<int>U{1, 2, 3};vektor<int>V{4, 5, 6};
bool bl=U! =V;
költség<<bl<< ' n';
A kimenet 1.
Az
Az igaz értéket adja vissza, ha az első vektor a második vektor kezdeti részhalmaza, ahol a két egyenlő rész elemei azonosak és ugyanabban a sorrendben vannak. Ha mindkét vektor azonos méretű és balról jobbra mozog, és az első vektorban olyan elemet találunk, amely kisebb, mint a második vektor megfelelő eleme, akkor az 1 továbbra is visszatér. Ellenkező esetben a 0 hamis értéket ad vissza. Például:
vektor<int>U{3, 1, 1};vektor<int>V{3, 2, 1};
bool bl=U<V;
költség<<bl<< ' n';
A kimenet 1. A> Kezelő Visszatér! (U Az<= Operator U -t ad vissza<= V, where U is the first vector and V is the second vector, according to the above definitions. A> = Kezelő Visszatér! (U<= V), where U is the first vector and V is the second vector, according to the above definitions. A vektor egy példa a szekvencia tárolóra. A vektor a szokásos tömb jobb formája, és egy osztályból származik. A vektoroknak módszerei vannak, amelyek a következők szerint vannak besorolva: felépítés és hozzárendelés, kapacitás, elemhozzáférés, adathozzáférés, iterátorok, módosítók és számszerű túlterhelt operátorok. Vannak más szekvencia tárolók is, listának, forward_listnek és tömbnek. Ha a feladat gyakori beszúrásokat és törléseket tartalmaz a sorozat közepén, akkor listát vagy forward_list -et kell használni. Ha a feladat gyakori beszúrásokat és törléseket tartalmaz a sorozat elején vagy végén, akkor egy dekort kell használni. Tehát a vektorokat csak akkor szabad használni, ha az ilyen típusú műveletek nem fontosak.Következtetés