Introducere
O matrice este o serie de aceleași tipuri de obiecte în locații consecutive de memorie. O matrice nu poate crește lungimea minereului. Un vector este ca un tablou, dar lungimea acestuia poate fi mărită sau redusă. Prin urmare, un vector are mult mai multe operații decât o matrice.
C ++ are multe biblioteci, toate formând biblioteca standard C ++. Una dintre aceste biblioteci este biblioteca de containere. Un container este o colecție de obiecte, iar anumite operațiuni pot fi efectuate asupra colecției. Containerele C ++ pot fi grupate în două seturi: containere secvențiale și containere asociative. Containerele de secvențe sunt vectoriale, matrice (nu aceeași matrice discutate anterior), deque, forward_list și listă. Acestea sunt colecții diferite (structuri de date în formă de matrice) și fiecare oferă compromisuri distincte.
Orice programator ar trebui să știe cum să decidă dacă folosește un vector, o matrice, un deque, o listă forward_ sau o listă. Atunci când un programator are nevoie de o structură care necesită mai multe operații decât cele asociate cu o matrice obișnuită, matricea obișnuită nu trebuie utilizată.
Dacă sarcina implică inserări și ștergeri frecvente în mijlocul secvenței, atunci ar trebui folosită o listă sau o listă forward_list. Dacă sarcina implică inserări și ștergeri frecvente la începutul sau la sfârșitul unei secvențe, atunci trebuie utilizat un deque. Ar trebui să se utilizeze un vector când nu sunt necesare astfel de operații.
Acest articol vă arată cum să utilizați vectorul C ++. Veți avea nevoie de cunoștințe despre indicii, referințe și tablouri C ++ pentru a înțelege acest articol.
Clasa și obiecte
O clasă este un set de variabile și funcții care funcționează împreună, în care variabilele nu au valori atribuite. Când valorile sunt atribuite variabilelor, o clasă devine obiect. Valori diferite date aceleiași clase rezultă în obiecte diferite; adică diferite obiecte pot fi din aceeași clasă, dar au valori diferite. Crearea unui obiect dintr-o clasă este cunoscută și ca instanțierea obiectului.
Termenul vector descrie o clasă. Un obiect creat dintr-un vector are un nume ales de programator.
O funcție care aparține unei clase este necesară pentru a crea un obiect din clasă. În C ++, acea funcție are același nume ca și numele clasei. Diferite obiecte create (instanțiate) din clasă au nume distincte date fiecăruia de către programator.
Crearea unui obiect dintr-o clasă înseamnă construirea obiectului; înseamnă și instanțierea obiectului.
Clasa Vector
Clasa vector a fost deja definită și se află în bibliotecă. Pentru a utiliza clasa vectorială, un programator trebuie să includă antetul vectorului în fișier cu următoarea directivă de preprocesare:
#includeOdată ce antetul este inclus, toate caracteristicile vectoriale (membrii de date și funcții de membru) devin accesibile. Pentru a utiliza obiectul de numărare pentru a transmite date către terminal (consolă), trebuie inclus și antetul obiectului. Pentru a scrie un program cu vectorul, cel puțin, trebuie incluse următoarele anteturi:
#include#include
Instanțierea unui vector
intfoo[10];Mai sus este declarația unui tablou cu numele foo și numărul de elemente 10. Acesta este un tablou de numere întregi. Declarația unui vector este similară. Pentru un vector, numărul de elemente este opțional, deoarece lungimea vectorului poate crește sau scădea.
În acest moment al programului, clasa vectorului a fost deja definită în bibliotecă, iar antetul a fost inclus. Vectorul poate fi instanțiat după cum urmează:
ore::vector <int>vtr(8);Aici, vectorul este al funcției speciale de constructor. Tipul de date pe care vectorul le va păstra este int, între paranteze unghiulare. Termenul vtr este numele ales de programator pentru vector. În cele din urmă, 8, între paranteze, este numărul provizoriu de numere întregi pe care vectorul le va avea.
Termenul std înseamnă spațiu de nume standard. Acest termen trebuie să fie urmat de un punct dublu, în acest context. Oricine își poate scrie propria bibliotecă de clase vectoriale și o poate folosi. Cu toate acestea, C ++ are deja o bibliotecă standard cu nume standard, inclusiv vector. Pentru a utiliza un nume standard, numele standard trebuie să fie precedat de std ::. Pentru a evita tastarea std :: de fiecare dată în program pentru un nume standard, fișierul programului poate începe astfel:
#include#include
folosind spațiul de nume std;
Supraîncărcarea unei funcții
Când două sau mai multe semnături de funcții diferite au același nume, se spune că acel nume este suprasolicitat. Când se apelează o funcție, numărul și tipul argumentelor determină ce funcție este executată.
Construirea unui vector
Construirea unui vector înseamnă instanțierea (crearea) unui obiect vector. Funcția constructor este supraîncărcată după cum urmează:
numele vectorului
Aceasta creează un vector cu lungimea zero și tipul T. Următoarea declarație creează un vector cu lungimea zero a tipului float cu numele vtr:
vector<pluti>vtr;nume vector (n)
Aceasta creează un vector cu n elemente de tip T. O declarație pentru acest vector cu patru elemente plutitoare este următoarea:
vector<pluti>vtr(4);numele vectorului (n, t)
Aceasta creează un vector de n elemente inițializate la valoarea t. Următoarea declarație creează un vector de 5 elemente, unde fiecare element are valoarea 3.4:
vector<pluti>vtr(5, 3.4);Construirea cu inițializare
Un vector poate fi construit (creat) și inițializat în același timp, într-unul din următoarele două moduri:
vector<pluti>vtr= {1.1, 2.2, 3.3, 4.4};Sau
vector<pluti>vtr{1.1, 2.2, 3.3, 4.4};Rețineți că nu există paranteze imediat după numele obiectului. Parantezele utilizate imediat după numele obiectului ar trebui să aibă lista de inițializatoare, după cum urmează:
vector<pluti>vtr({1.1, 2.2, 3.3, 4.4});Un vector poate fi construit și inițializat ulterior cu lista de inițializatoare. În acest caz, parantezele nu vor fi folosite:
vector<pluti>vtr;vtr= {1.1, 2.2, 3.3, 4.4};
vectorul V2 (V1)
Acesta este un constructor de copii. Se creează un vector V2 ca o copie a vectorului V1. Următorul cod ilustrează acest lucru:
vector<pluti>vtr1(5, 3.4);vector<pluti>vtr2(vtr1);
Atribuirea unui vector în timpul construcției
În timpul construcției, un vector gol poate fi creat în timp ce i se atribuie altul, după cum urmează:
vector<pluti>vtr1{1.1, 2.2, 3.3, 4.4};vector<pluti>vtr2=vtr1;
A doua afirmație este echivalentă cu:
vector<pluti>vtr2= {1.1, 2.2, 3.3, 4.4};const Vector
Un vector const este un vector ale cărui elemente nu pot fi modificate. Valorile din acest vector sunt numai în citire. Când este creat, vectorul apare după cum urmează:
constvector<pluti>vtr{1.1, 2.2, 3.3, 4.4};În acest tip de vector, niciun element nu poate fi adăugat sau eliminat. Mai mult, nici o valoare nu poate fi schimbată.
Construirea cu Iterator
Un șablon oferă o reprezentare generică pentru un tip de date. Un iterator oferă o reprezentare generică a scanării prin valorile unui container. Sintaxa pentru a crea un vector cu un iterator este după cum urmează:
șablon<clasa InputIterator>vector(InputIterator mai întâi,InputIterator ultima,constAlocator& =Alocator());
Aceasta construiește un vector pentru intervalul [primul, ultimul] folosind alocatorul specificat, care va fi discutat mai târziu în acest articol.
Distrugerea unui vector
Pentru a distruge un vector, pur și simplu permiteți-i să iasă din scop și distrugerea este tratată automat.
Capacitate vectorială
size_type capacity () const noexcept
Numărul total de elemente pe care vectorul le poate deține fără a necesita realocare este returnat de funcția membru capacitate. Un segment de cod pentru aceasta este următorul:
vector<pluti>vtr(4);intpe unu=vtr.capacitate();
cost<<pe unu<< ' n';
Ieșirea este 4.
rezerva (n)
Spațiul de memorie nu este întotdeauna disponibil liber. Spațiu suplimentar poate fi rezervat în avans. Luați în considerare următorul segment de cod:
vector<pluti>vtr(4);vtr.rezervă(6);
cost<<vtr.capacitate() << ' n';
Ieșirea este 6. Deci, spațiul suplimentar rezervat este de 6 - 4 = 2 elemente. Funcția returnează nul.
size () const noexcept
Aceasta returnează numărul de elemente din vector. Următorul cod ilustrează această funcție:
vector<pluti>vtr(4);plutis=vtr.mărimea();
cost<<s<< ' n';
Ieșirea este 4.
shrink_to_fit ()
După acordarea unei capacități suplimentare unui vector cu funcția de rezervare (), vectorul poate fi redus pentru a se potrivi cu dimensiunea inițială. Următorul cod ilustrează acest lucru:
vector<pluti>vtr(4);vtr.rezervă(6);
vtr.shrink_to_fit();
ints=vtr.mărimea();
cost<<s<< ' n';
Ieșirea este 4 și nu 6. Funcția returnează nul.
redimensionare (sz), redimensionare (sz, c)
Aceasta redimensionează vectorul. Dacă noua dimensiune este mai mică decât dimensiunea veche, atunci elementele spre final sunt șterse. Dacă noua dimensiune este mai lungă, atunci se adaugă o anumită valoare implicită spre final. Pentru a avea o anumită valoare adăugată, utilizați funcția resize () cu două argumente. Următorul segment de cod ilustrează utilizarea acestor două funcții:
vector<pluti>vtr1{1.1, 2.2, 3.3, 4.4};vtr1.redimensionare(2);
cost<< „Dimensiune nouă a vtr1:” <<vtr1.mărimea() << ' n';
vector<pluti>vtr2{1.1, 2.2};
vtr2.redimensionare(4, 8.8);
cost<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'<<vtr2[2] <<''<<vtr2[3] << ' n';
Ieșirea este următoarea:
Nouă dimensiune vtr1: 2vtr2: 1,1 2,2 8,8 8,8
Funcțiile revin nule.
empty () const noexcept
Această funcție returnează 1 pentru adevărat dacă nu există elemente în vector și 0 pentru fals dacă vectorul este gol. Dacă un vector are 4 locații pentru un anumit tip de date, cum ar fi float, fără nicio valoare float, atunci acel vector nu este gol. Următorul cod ilustrează acest lucru:
vector<pluti>vtr;cost<<vtr.gol() << ' n';
vector<pluti>vt(4);
cost<<astfel încâtgol() << ' n';
vector<pluti>v(4,3.5);
cost<<v.gol() << ' n';
Ieșirea este următoarea:
10
0
Acces element vector
Un vector poate fi sub-scriptat (indexat) ca o matrice. Numărarea indexului începe de la zero.
vectorName [i]
Operația vectorName [i] returnează o referință la elementul de la iaindexul vectorului. Următorul cod scoate 3.3 pentru vectorul de mai sus:
vector<pluti>vtr{1.1, 2.2, 3.3, 4.4};plutifl=vtr[2];
cost<<fl<< ' n';
vectorName [i] const
Operația vectorName [i] const este executată în locul vectorName [i] atunci când vectorul este un vector constant. Această operație este utilizată în următorul cod:
constvector<pluti>vtr{1.1, 2.2, 3.3, 4.4};plutifl=vtr[2];
cost<<fl<< ' n';
Expresia returnează o referință constantă la iaelement al vectorului.
Atribuirea unei valori cu subscript
O valoare poate fi atribuită unui vector neconstant, după cum urmează:
vector<pluti>vtr{1.1, 2.2, 3.3, 4.4};vtr[2] = 8.8;
cost<<vtr[2] << ' n';
Ieșirea este de 8,8.
vectorName.at (i)
vectorName.at (i) este ca vectorName [i], dar vectorName.at (i) este mai fiabil. Următorul cod arată modul în care ar trebui utilizat acest vector:
vector<pluti>vtr{1.1, 2.2, 3.3, 4.4};plutifl=vtr.la(2);
cost<<fl<< ' n';
la()este un membru vectorfuncţie.
vectorName.at (i) const
vectorName.at (i) const este ca vectorName [i] const, dar vectorName.at (i) const este mai fiabil. vectorName.at (i) const este executat în loc de vectorName.at (i) când vectorul este un vector constant. Acest vector este utilizat în următorul cod:
constvector<pluti>vtr{1.1, 2.2, 3.3, 4.4};plutifl=vtr.la(2);
cost<<fl<< ' n';
la() consteste un membru vectorfuncţie.
Atribuirea unei valori cu funcția at ()
O valoare poate fi atribuită unui vector neconstant cu funcția at (), după cum urmează:
vector<pluti>vtr{1.1, 2.2, 3.3, 4.4};vtr.la(2) = 8.8;
cost<<vtr[2] << ' n';
Ieșirea este de 8,8.
Problemă cu Sub-Scripting
Problema cu sub-scriptarea (indexarea) este că, dacă indexul este în afara intervalului, poate fi returnat zero sau poate fi emisă o eroare în timpul rulării.
față()
Aceasta returnează o referință la primul element al vectorului fără a elimina elementul. Ieșirea următorului cod este 1.1.
vector<pluti>vtr{1.1, 2.2, 3.3, 4.4};plutifl=vtr.față();
cost<<fl<< ' n';
Elementul nu este eliminat din vector.
front () const
Când construcția vectorială este precedată de const, expresia front () const este executată în loc de front (). Acesta este utilizat în următorul cod:
constvector<pluti>vtr{1.1, 2.2, 3.3, 4.4};plutifl=vtr.față();
cost<<fl<< ' n';
Se returnează o referință constantă. Elementul nu este eliminat din vector.
înapoi()
Aceasta returnează o referință la ultimul element al vectorului fără a elimina elementul. Ieșirea următorului cod este 4.4.
vector<pluti>vtr{1.1, 2.2, 3.3, 4.4};plutifl=vtr.înapoi();
cost<<fl<< ' n';
back () const
Când construcția vectorială este precedată de const, expresia back () const este executată în loc de back (). Acesta este utilizat în următorul cod:
constvector<pluti>vtr{1.1, 2.2, 3.3, 4.4};plutifl=vtr.înapoi();
cost<<fl<< ' n';
Se returnează o referință constantă. Elementul nu este eliminat din vector.
Acces la date vectoriale
data () fără excepție; data () const noexcept;
Oricare dintre acestea returnează un indicator astfel încât [data (), data () + size ()) să fie un interval valid.
Acest lucru va fi tratat în detaliu mai târziu în articol.
Iteratorii care revin și vectorul
Un iterator este ca un pointer, dar are mai multe funcționalități decât un pointer.
begin () noexcept
Returnează un iterator care indică primul element al vectorului, ca în următorul segment de cod:
vector<pluti>vtr{1.1, 2.2, 3.3, 4.4};vector<pluti> ::iteratoriter=vtr.începe();
cost<< *iter<< ' n';
Ieșirea este 1.1. Rețineți că declarația care primește iteratorul a fost declarată. Iteratorul este dereferențiat într-o expresie returnată pentru a obține valoarea în același mod în care un pointer este dereferențiat.
begin () const noexcept;
Returnează un iterator care indică primul element al vectorului. Când construcția vectorială este precedată de const, expresia begin () const este executată în loc de begin (). În această condiție, elementul corespunzător din vector nu poate fi modificat. Acesta este utilizat în următorul cod:
constvector<pluti>vtr{1.1, 2.2, 3.3, 4.4};vector<pluti> ::const_iteratoriter=vtr.începe();
cost<< *iter<< ' n';
Ieșirea este 1.1. Rețineți că const_iterator a fost folosit de această dată în loc de doar iterator pentru a primi iteratorul returnat.
end () noexcept
Returnează un iterator care indică imediat dincolo de ultimul element al vectorului. Luați în considerare următorul segment de cod:
vector<pluti>vtr{1.1, 2.2, 3.3, 4.4};vector<pluti> ::iteratoriter=vtr.Sfârșit();
cost<< *iter<< ' n';
Rezultatul este 0, ceea ce nu are sens, deoarece nu există niciun element concret dincolo de ultimul element.
end () const noexcept
Returnează un iterator care indică imediat dincolo de ultimul element al vectorului. Când construcția vectorială este precedată de const, expresia end () const este executată în loc de end (). Luați în considerare următorul segment de cod:
constvector<pluti>vtr{1.1, 2.2, 3.3, 4.4};vector<pluti> ::const_iteratoriter=vtr.Sfârșit();
cost<< *iter<< ' n';
Ieșirea este 0. Rețineți că const_iterator a fost folosit de această dată în loc de doar iterator pentru a primi iteratorul returnat.
Iterare inversă
Este posibil să aveți un iterator care iterează de la sfârșit până chiar înainte de primul element.
rbegin () noexcept
Returnează un iterator care indică ultimul element al vectorului, ca în următorul segment de cod:
vector<pluti>vtr{1.1, 2.2, 3.3, 4.4};vector<pluti> ::invers_iteratorrIter=vtr.rbegin();
cost<< *rIter<< ' n';
Ieșirea este de 4,4.
Rețineți că declarația care primește iteratorul invers a fost declarată. Iteratorul este dereferențiat într-o expresie returnată pentru a obține valoarea în același mod în care un pointer este dereferențiat.
rbegin () const noexcept;
Returnează un iterator care indică ultimul element al vectorului. Când construcția vectorială este precedată de const, expresia rbegin () const este executată în loc de rbegin (). În această condiție, elementul corespunzător din vector nu poate fi modificat. Această caracteristică este utilizată în următorul cod:
constvector<pluti>vtr{1.1, 2.2, 3.3, 4.4};vector<pluti> ::const_reverse_iteratorrIter=vtr.rbegin();
cost<< *rIter<< ' n';
Ieșirea este de 4,4.
Rețineți că const_reverse_iterator a fost folosit de această dată, în loc doar de reverse_iterator, pentru a primi iteratorul returnat.
render () noexcept
Returnează un iterator care indică chiar înainte de primul element al vectorului. Luați în considerare următorul segment de cod:
vector<pluti>vtr{1.1, 2.2, 3.3, 4.4};vector<pluti> ::invers_iteratorrIter=vtr.face();
cost<< *rIter<< ' n';
Ieșirea este 0, ceea ce nu are sens, deoarece nu există niciun element concret chiar înainte de primul element.
render () const noexcept
Returnează un iterator care indică chiar înainte de primul element al vectorului. Când construcția vectorială este precedată de const, expresia rend () const este executată în loc de rend (). Luați în considerare următorul segment de cod:
constvector<pluti>vtr{1.1, 2.2, 3.3, 4.4};vector<pluti> ::const_reverse_iteratorrIter=vtr.face();
cost<< *rIter<< ' n';
Ieșirea este 0.
Rețineți că const_reverse_iterator a fost folosit de această dată, în loc doar de reverse_iterator, pentru a primi iteratorul returnat.
Modificatori vectoriali
Un modificator care modifică vectorul poate lua sau returna un iterator.
a. model (p, args)
Inserează un obiect de tip T construit cu std :: forward (args) ... înainte de p.
Pentru detalii - vezi mai târziuinsert (iteratorPosition, valoare)
Inserează o copie a valorii în poziția iteratorului vectorului. Returnează iteratorul (poziția) în vectorul în care a fost plasată copia. Următorul cod arată unde a fost plasată valoarea:
vector<int>vtr{10, douăzeci, 30, 40};vector<int> ::iteratoriter=vtr.începe();
++iter;
++iter;
vtr.introduce(iter, 25);
cost<<vtr[1] << '' <<vtr[2]<< '
' <<vtr[3] << ' n';
Ieșirea este: 20 25 30.
Rețineți că iteratorul a fost avansat (incrementat) la fel ca un indicator.
De asemenea, poate fi inserată o listă de inițializatoare, așa cum ilustrează următorul cod:
vector<int>vtr{10, douăzeci, 30, 40};vector<int> ::iteratoriter=vtr.începe();
++iter;
++iter;
vtr.introduce(iter, {25, 28});
cost<<vtr[1] << '' <<vtr[2]<< '
' <<vtr[3]<< '' <<vtr[4] << ' n';
Ieșirea este: 20 25 28 30.
șterge (poziție)
Elimină un element în poziția indicată de iterator, apoi returnează poziția iteratorului. Următorul cod ilustrează acest lucru:
vector<int>vtr{10, douăzeci, 30, 40};vector<int> ::iteratoriter=vtr.începe();
++iter;
++iter;
vtr.şterge(iter);
cost<<vtr[0] << '' <<vtr[1] << '
' <<vtr[2]<< ' n';
Ieșirea este: 10 20 40
push_back (t), push_back (rv)
Folosit pentru a adăuga un singur element la sfârșitul vectorului. Utilizați push_back (t) după cum urmează:
vector<pluti>vtr{1.1, 2.2, 3.3, 4.4};vtr.împinge înapoi(5.5);
plutifl=vtr[4];
cost<<fl<< ' n';
Ieșirea este de 5,5.
împinge înapoi(rv): -ne vedem mai tarziu.pop_back ()
Elimină ultimul element fără a-l returna. Dimensiunea vectorului este redusă cu 1. Următorul cod ilustrează acest lucru:
vector<pluti>vtr{1.1, 2.2, 3.3, 4.4};vtr.pop_back();
plutis=vtr.mărimea();
cost<<s<< ' n';
Ieșirea este 3.
a. swap (b)
Se pot schimba doi vectori, așa cum se ilustrează în următorul segment de cod:
vector<pluti>vtr1{1.1, 2.2, 3.3, 4.4};vector<pluti>vtr2{10, douăzeci};
vtr1.swap(vtr2);
cost<< 'vtr1:'<<vtr1[0] <<''<<vtr1[1] <<'
'<<vtr1[2] <<''<<vtr1[3] << ' n';
cost<< 'vtr2:'<<vtr2[0] <<''<<vtr2[1] <<'
'<<vtr2[2] <<''<<vtr2[3] << ' n';
Ieșirea este:
vtr1: 10 douăzeci 0 0vtr2: 1.1 2.2 3.3 4.4
Rețineți că lungimea unui vector este mărită, dacă este necesar. De asemenea, valorile care nu au avut înlocuiri sunt înlocuite cu o anumită valoare implicită.
clar()
Elimină toate elementele din vector, așa cum ilustrează următorul segment de cod:
vector<pluti>vtr{1.1, 2.2, 3.3, 4.4};vtr.clar();
cost<<vtr.mărimea() << ' n';
Ieșirea este 0.
Egalitatea și operatorii relaționali pentru vectori
Operatorul ==
Returnează 1 pentru adevărat dacă cei doi vectori au aceeași dimensiune și elementele corespunzătoare sunt egale; în caz contrar, returnează 0 pentru fals. De exemplu:
vector<int>U{1, 2, 3};vector<int>V{4, 5, 6};
bool bl=U==V;
cost<<bl<< ' n';
Ieșirea este 0.
Operatorul! =
Returnează 1 pentru adevărat dacă cei doi vectori nu au aceeași dimensiune și / sau elementele corespunzătoare nu sunt egale; în caz contrar, returnează 0 pentru fals. De exemplu:
vector<int>U{1, 2, 3};vector<int>V{4, 5, 6};
bool bl=U! =V;
cost<<bl<< ' n';
Ieșirea este 1.
The
Returnează 1 pentru adevărat dacă primul vector este subsetul inițial al celui de-al doilea vector, elementele celor două porțiuni egale fiind aceleași și în aceeași ordine. Dacă ambii vectori sunt de aceeași dimensiune și se mișcă de la stânga la dreapta și un element este întâlnit în primul vector care este mai mic decât elementul corespunzător din al doilea vector, atunci 1 va fi totuși returnat. În caz contrar, se returnează 0 pentru fals. De exemplu:
vector<int>U{3, 1, 1};vector<int>V{3, 2, 1};
bool bl=U<V;
cost<<bl<< ' n';
Ieșirea este 1. > Operatorul Revine! (U The<= Operator Returnează U<= V, where U is the first vector and V is the second vector, according to the above definitions. Operatorul> = Revine! (U<= V), where U is the first vector and V is the second vector, according to the above definitions. Un vector este un exemplu de container de secvență. Un vector este o formă mai bună a matricei obișnuite și este instanțiat dintr-o clasă. Vectorii au metode care sunt clasificate în: construcție și atribuire, capacitate, acces la elemente, acces la date, iteratori, modificatori și operatori numerici supraîncărcați. Există alte containere de secvență, numite listă, forward_list și matrice. Dacă sarcina implică inserări și ștergeri frecvente în mijlocul secvenței, atunci ar trebui folosită o listă sau o listă forward_list. Dacă sarcina implică inserări și ștergeri frecvente la începutul sau la sfârșitul secvenței, atunci trebuie utilizat un deque. Deci, vectorii ar trebui utilizați numai atunci când aceste tipuri de operații nu sunt importante.Concluzie