Vectorul

Vectorul reprezintă un container care conține o colecție de obiecte de același tip. Pentru a lucra cu vectori, este necesar să fie inclus antetul:

#include <vector>

Definim un vector simplu:

std::vector<int> numbers;

În paranteze unghiulare se specifică tipul obiectelor care vor fi stocate în vector. Adică vectorul numbers va stoca obiecte de tip int. Totuși, acest vector este gol. El nu conține niciun element.

Putem însă inițializa un vector în unul dintre următoarele moduri:

std::vector<int> v1;              // vector gol
std::vector<int> v2(v1);          // vectorul v2 este o copie a vectorului v1
std::vector<int> v3 = v1;         // vectorul v3 este o copie a vectorului v1
std::vector<int> v4(5);           // vectorul v4 conține 5 numere, fiecare egal cu 0
std::vector<int> v5(5, 2);        // vectorul v5 conține 5 numere, fiecare egal cu 2
std::vector<int> v6{1, 2, 4, 5};  // vectorul v6 conține numerele 1, 2, 4, 5
std::vector<int> v7 = {1, 2, 3, 5}; // vectorul v7 conține numerele 1, 2, 3, 5

Este important să înțelegem diferența dintre parantezele rotunde și cele acolade:

std::vector<int> v1(5);       // vectorul conține 5 numere, fiecare având valoarea 0
std::vector<int> v2{5};       // vectorul conține un singur număr: 5
std::vector<int> v3(5, 2);    // vectorul conține 5 numere, fiecare având valoarea 2
std::vector<int> v4{5, 2};    // vectorul conține două numere: 5 și 2

Este permis să fie stocate în vector doar elemente de un singur tip – cel indicat între paranteze unghiulare. Nu se pot stoca valori de alte tipuri în vector, ca în următorul caz incorect:

std::vector<int> v{5, "hi"}; // eroare

Accesul la elemente și parcurgerea acestora

Pentru a accesa elementele unui vector, se pot utiliza mai multe metode:

[index]: accesarea unui element după index (la fel ca în tablouri), indexarea începe de la zero
at(index): funcție care returnează elementul de la un anumit index
front(): returnează primul element
back(): returnează ultimul element

Executăm o parcurgere a vectorului și obținem câteva dintre elementele sale:

#include <iostream>
#include <vector>
  
int main()
{
    std::vector<int> numbers {1, 2, 3, 4, 5};
     
    int first = numbers.front();    // 1
    int last = numbers.back();      // 5
    int second = numbers[1];        // 2
    std::cout << "first: " << first << std::endl;
    std::cout << "second: " << second << std::endl;
    std::cout << "last: " << last << std::endl;
 
    numbers[0] = 6;  // modificăm valoarea
    for(int n : numbers)
        std::cout << n << "\t"; // 6  2  3  4  5
     
    std::cout << std::endl;
}

Este important de reținut că accesarea prin index nu adaugă elemente noi. De exemplu, dacă vectorul conține 5 elemente, nu putem accesa al șaselea:

std::vector<int> numbers {1, 2, 3, 4, 5};
numbers[5] = 9; // comportament nedefinit

În acest caz, rezultatul este nedefinit. Unii compilatori pot genera eroare, alții vor continua să ruleze, dar oricum aceasta este o greșeală, iar accesul nu va adăuga un element nou.

Pentru a evita astfel de situații, putem folosi funcția at(), care de asemenea returnează un element după index, dar dacă indexul este invalid, va genera o excepție de tip out_of_range:

#include <iostream>
#include <vector>
#include <stdexcept>
 
int main()
{
    std::vector<int> numbers { 1, 2, 3, 4, 5};
    try
    {
        int n = numbers.at(8);
    }
    catch (std::out_of_range e)
    {
        std::cout << "Incorrect index" << std::endl;
    }
}