Candale Silviu (silviu) Containerul C++ vector este, probabil, cel mai folosit container STL. Vectorii sunt tablouri dinamice cu elemente omogene care au proprietatea de a se redimensiona automat când se adaugă sau se șterge un element, gestionarea memoriei fiind realizată automat de către container.
Vectorii sunt stocați într-o zonă contiguă de memorie și pot fi traversați cu ajutorul iteratorilor. Elementele se adaugă, de regulă la sfârșit. Operația de adăugare ia, de regulă, timp constant, cu excepția cazului când spatiul de memorie alocat trebuie redimensionat (mărit). Ștergerea unui element ia întotdeauna timp constant. Inserarea și ștergerea la începutul sau în interiorul vectorului iau timp liniar.
Declararea unui vector
Trebuie inclus header-ul vector:
#include <vector>;
Declararea se face astfel:
vector<T> V;
unde T este un tip de date. Acesta va fi tipul elementelor vectorului. Vectorul declarat mai sus este vid – are 0 elemente.
Alternativ, putem declara vectorul astfel:
vector<T> V(n);
n este un întreg. Se va crea un crea un vector V cu n elemente. Valorile acestora sunt valorile implicite pentru datele de tip T. Pentru tipurile numerice, valoarea elementelor este 0.
vector<T> V(n, vT);
n este un întreg, iar vT este o dată de tip T. Se va crea un crea un vector V cu n elemente. Valorile acestora sunt copii ale lui vT.
De exemplu:
vector<int> A; // se crează un vector A cu zero elemente cin >> n; vector<int> B(n); // se crează un vector B cu n elemente, egale cu 0 cin >> x; vector<int> C(n , x); // se crează un vector B cu n elemente, egale cu x
Atribuirea
Spre deosebire de tablourile standard C, vectorilor li se pot atribui valori în orice moment. Exemplu:
vector<int> A , B = {2 , 4, 6 , 8};
A = B;
A = {1 , 2 , 3 , 4 , 5};
Dimensiunea și capacitatea
Numărul de elemente din vector poate fi determinat cu funcția size():
vector<int> A = {2 , 4 , 6 , 8};
cout << A.size(); // 4
De regulă, memoria alocată pentru un vector este mai mare decât memoria folosită. Acest lucru se întâmplă pentru a se evita realocarea memoriei (operație costisitoare, care presupune copierea tuturor elementelor) de fiecare dată când se adaugă elemente.
Funcția capacity() returnează numărul de elemnte pe care le poate avea vectorul la momentul curent, fără a se realoca memoria. Are loc relația capacity() >= size(), iar numărul de elemente care pot fi adăugate fără realocare este capacity() - size().
Redimensionarea
Funcția resize() permite redimensionarea unui vector și are următoarele forme:
V.resize(n);(1)V.resize(n , x);(2)
Vectorul V se redimensionează încât să aibă n elemente:
- dacă
n < V.size(), în vector vor rămâne primelenelemente, celelalte vor fi șterse. - dacă
n > V.size(), în vector se vor adăugan - V.size()elemente egale cux, în cazul (2) sau egale cu valoarea implicită pentru tipul elementelor din vector, în cazul (1). Această valoare este0pentru tipurile numerice.
Adăugarea unui element
Adăugarea unui nou element în vector se face la sfârșit, cu funcția push_back():
vector<int> A; for(int i = 1 ; i <= 5 ; i ++) A.push_back(2 * i); cout << A.size();
Accesarea unui element
Elementele vectorilor pot fi accesate prin intermediul indicilor, cu operatorul []. Acesta nu verifică existență elementului cu un anumit indice, iar dacă acesta nu există, comportamentul programului este impredictibil.
vector<int> A; for(int i = 1 ; i <= 5 ; i ++) A.push_back(2 * i); for(int i = 0 ; i < A.size() ; i ++) cout << A[i] << ' '; // 0 2 4 6 8
De asemenea, este posibilă accesarea elementelor prin intermediul funcției at(). Aceasta returnează o referință la elementul de la poziția dată, iar dacă acesta nu există ridică o excepție care poate fi capturată prin mecanismul try … catch.
vector<int> A = {2 , 4 , 6 , 8 , 10};
A.at(1) = 20; //A = {2 , 20 , 6 , 8 , 10}
for(auto x : A)
cout << x << " ";
Primul și ultimul element poate fi accesat prin intemediul funcțiilor front() și back(). Ele returnează referințe la primul, respectiv ultimul element al vectorului. Comportamentul este impredictibil dacă vectorul este vid.
vector<int> A = {2 , 4 , 6 , 8 , 10};
A.at(1) = 20; //A = {2 , 20 , 6 , 8 , 10}
A.front() = 7; //A = {7 , 20 , 6 , 8 , 10}
A.back() = 5; //A = {7 , 20 , 6 , 8 , 5}
for(auto x : A)
cout << x << " ";
Iteratori
Iteratorii sunt similari cu pointerii. Cu ajutorul lor putem identifica adresa elementelor din vector. Iteratorii pot fi dereferențiați (obtinând referințe la elemente), pot fi incrementați/decrementați și pot fi adunați cu scalari.
Vectorii oferă prin intermediul funcției begin() un iterator la primul element al funcției, iar prin end() un iterator la elementul de după ultimul element al vectorului.
vector<int> A = {2 , 4 , 6 , 8 , 10};
vector<int>::iterator I;
for(I = A.begin() ; I < A.end() ; I ++)
cout << *I << " "; // 2 4 6 8 10
Observații:
- tipul variabilei iterator trebuie să fie în concordanță cu tipul elementelor vectorului;
- pentru a lucra cu elementul pentru care cunoaștem iteratorul, acesta trebuie să fie dereferențiat:
*I; - rezultatul funcției
A.end()este un iterator, dar acestuia nu-i corespunde un element al vectorului. Valoarea sa este adresa de după ultimul element al vectorului.
Clasa vector conține și funcțiile rbegin() și rend(), care returnează iteratori de tip reverse iterator, care permit parcurgerea vectorului în ordien inversă:
vector<int> A = {2 , 4 , 6 , 8 , 10};
for(vector<int>::reverse_iterator I = A.rbegin() ; I < A.rend() ; I ++)
cout << *I << " ";
Acești iteratori fac parte din categoria iteratorilor cu acces aleatoriu. Este cea mai puternică categorie de iteratori (cu cele mai multe operații definite). Aceste operații sunt:
| Expresie | Rezultat, efect |
|---|---|
*I |
Dereferențiere |
I->camp |
Acces la câmpurile structurii/membrii clasei memorate în elementele vectorului |
++I |
Preincrementare. Rezultatul este poziția următoare |
I++ |
Postincrementare. Rezultatul este poziția inițială |
--I |
Predecrementare. Rezultatul este poziția anterioară |
I-- |
Postdecrementare. Rezultatul este poziția inițială |
I == J |
Egalitate între doi iteratori |
I != J |
Neegalitate între doi iteratori |
<, >, <=, >= |
Operatori relaționali. Operanzii sunt iteratorii. Rezultatul este conform cu poziția în vector a elementelor adresate de cei doi iteratori |
I[k] |
Elementul de pe poziția k, începând de la I |
I += k |
k pași înainte |
I -= k |
k pași înapoi |
I + k |
iterator spre al k-lea element după cel curent |
I - k |
iterator spre al k-lea element înaintea celui curent |
I - J |
distanța în vector între iteratorii I și J |
Parcurgerea unui vector
O primă modalitate de parcurgere este folosind indicii, similar cu parcurgerea tablourilor standard C. Pentru determinarea numărului de elemnte există functia size():
vector<int> A = {2 , 4 , 6 , 8 , 10};
for(int i = 0 ; i < A.size(); i ++)
cout << A[i] << " ";
De asemenea, putem folosi iteratorii:
vector<int> A = {2 , 4 , 6 , 8 , 10};
for(vector<int>::iterator I = A.begin() ; I < A.end() ; I ++)
cout << *I << " ";
Pentru ușurință, putem folosi specificatorul de tip auto pentru a stabili tipul iteratorului:
vector<int> A = {2 , 4 , 6 , 8 , 10};
for(auto I = A.begin() ; I < A.end() ; I ++)
cout << *I << " ";
Începând de la versiunea 2011 a standardului C++ există o formă specială a instrucțiunii for, care permite parcurgerea elementelor unui container:
vector<int> A = {2 , 4 , 6 , 8 , 10};
for(int x : A)
cout << x << " ";
Specificatorul de tip auto poate fi folosit și aici. În secvența de mai sus, x reprezintă pe rând câte o copie a elementelor din A. Eventualele modificări ale lui x nu vor modifica valorile elementelor din A. Dacă se dorește modificare elemenelor din A, atunci x trebuie să fie o referință:
vector<int> A = {2 , 4 , 6 , 8 , 10};
for(int & x : A)
x *= 2;
for(int x : A)
cout << x << " ";
Parcurgerea inversă
Vectorii suportă iteratori reversibili, care permit parcurgerea containerului în ordine inversă. Clasa vector are metodele:
rbegin()– returnează un iterator reversibil la ultimul element din containerrend()– returnează un iterator reversibil la elementul din fața primului
Parcurgerea se poate face astfel:
for(vector<int>::reverse_iterator I = V.rbegin() ; I < V.rend() ; I ++) cout << *I << " ";
Inserarea elementelor
Pentru adăugarea la sfârșit se folosește metoda push_back(). Pentru inserarea de noi elemente în interiorul containerului se folosește metoda insert(), care are mai multe forme:
V.insert(pos , x)– inserează în vectorulV, în fața iteratoruluiposun nou element cu valoareax;V.insert(pos , cnt , x)inserează în vectorulV, în fața iteratoruluipos,cntnoi elemente egale cux;V.insert(pos , st , dr)inserează în vectorulV, în fața iteratoruluipos,dr-stnoi elemente, având valorile egale cu cele ale elementelor din secvența[st, dr)dintr-un container oarecare. Dacă vectorulVși secvența[st,dr)se suprapun rezultatul este impredictibil.
Rezultatul apelurilor de mai sus este un iterator la primul element inserat.
Apelurile de mai sus invalidează toți iteratorii și referințele la elemente din V, dacă în urma inserării se realocă memorie, respectiv se invalidează iteratorii și referințele din dreapta lui pos, în caz contrar.
Mai multe detalii despre insert() aici: https://en.cppreference.com/w/cpp/container/vector/insert.
Eliminarea elementelor
Pentru eliminarea tuturor elementelor intr-un vector există metoda clear().
V.clear();
În urma eliminării, rezultatul lui V.size() este 0.
Pentru eliminarea ultimului element al tabloului există metoda pop_back(). În urma apelului se invalidează iteratorii și referințele la ultimul element, precum și iteratorul end().
Pentru eliminarea unor elemente oarecare se folosește metoda erase(), cu următoarele forme:
V.erase(pos)– elimină elementul indicat de iteratorulpos.posnu poate fi egal cuend()V.erase(st , dr)– elimină elementele din intervalul[st,dr), undestșidrsunt iteratori la elemente dinV
Rezultatul funcției erase() este un iterator la elementul de după ultimul element eliminat.
Se invalidează iteratorii și iteratorii din dreapta lui posm inclusiv iteratorul end().
Mai multe detalii aici: https://en.cppreference.com/w/cpp/container/vector/erase.