std::vector în C++

#include <vector>

std::vector<T> nume;
std::vector<T> nume{v1, v2, v3};
std::vector<T> nume(n, valoare);

Ce face std::vector

std::vector este containerul pe care îl vei folosi cel mai des. Este un tablou care își gestionează singur memoria: adaugi elemente la final cu push_back, iar vectorul crește cât are nevoie. Elementele stau unul lângă altul în memorie, deci accesul după poziție (v[i]) este foarte rapid.

Între parantezele unghiulare scrii tipul elementelor: std::vector<int> pentru numere întregi, std::vector<std::string> pentru texte. Toate elementele au același tip. Pozițiile încep de la 0, iar size() spune câte elemente are vectorul.

Adăugarea și ștergerea la final sunt rapide. Inserarea sau ștergerea la început sau la mijloc mută toate elementele de după, deci costă mai mult pe vectori mari. Dacă nu ai un motiv clar să alegi alt container, alege std::vector. În C++23, std::println("{}", v) afișează direct tot vectorul.

Parametri

Parametru	Descriere
T	Tipul elementelor: int, double, std::string, o structură proprie etc.
{v1, v2, v3}	Lista de valori inițiale (acoladele).
(n, valoare)	Creează n elemente egale cu valoare (parantezele rotunde). Fără valoare, elementele sunt 0 sau construite implicit.

Ce returnează

Un obiect vector. Funcțiile lui membre (push_back, size, at etc.) au pagini separate.

Exemple

Exemplul 1: Moduri de a crea un vector

Acoladele dau lista de elemente; parantezele rotunde dau numărul de elemente și valoarea lor.

#include <print>
#include <string>
#include <vector>

int main() {
    std::vector<int> goale;                       // fără elemente
    std::vector<int> note{9, 7, 10};              // trei elemente: 9, 7, 10
    std::vector<double> preturi(4, 2.5);          // patru elemente egale cu 2.5
    std::vector<std::string> orase{"Iași", "Cluj"};

    std::println("goale:   {} (size = {})", goale, goale.size());
    std::println("note:    {}", note);
    std::println("preturi: {}", preturi);
    std::println("orase:   {}", orase);
}

Rezultat

goale:   [] (size = 0)
note:    [9, 7, 10]
preturi: [2.5, 2.5, 2.5, 2.5]
orase:   ["Iași", "Cluj"]

Exemplul 2: Adăugare, parcurgere și calcul

Bucla for (int nota : note) trece prin fiecare element, în ordine. const auto& evită copierea textelor.

#include <print>
#include <string>
#include <vector>

int main() {
    std::vector<int> note;
    note.push_back(8);
    note.push_back(10);
    note.push_back(7);

    int suma = 0;
    for (int nota : note) {
        suma += nota;
    }
    std::println("Ana are {} note: {}", note.size(), note);
    std::println("Media: {:.2f}", static_cast<double>(suma) / static_cast<double>(note.size()));

    std::vector<std::string> produse{"pâine", "lapte", "ouă"};
    for (const auto& produs : produse) {
        std::println("- {}", produs);
    }
}

Rezultat

Ana are 3 note: [8, 10, 7]
Media: 8.33
- pâine
- lapte
- ouă

Exemplul 3: Vector de vectori (tabel)

Fiecare element al vectorului exterior este tot un vector: un rând din tabel. tabel[r][c] citește elementul din rândul r, coloana c.

#include <print>
#include <vector>

int main() {
    std::vector<std::vector<int>> tabel(3, std::vector<int>(4, 0));   // 3 rânduri, 4 coloane
    for (std::size_t r = 0; r < tabel.size(); ++r) {
        for (std::size_t c = 0; c < tabel[r].size(); ++c) {
            tabel[r][c] = static_cast<int>((r + 1) * (c + 1));
        }
    }
    for (const auto& rand : tabel) {
        std::println("{}", rand);
    }
}

Rezultat

[1, 2, 3, 4]
[2, 4, 6, 8]
[3, 6, 9, 12]

Greșeli frecvente

• Confunzi acoladele cu parantezele: std::vector<int> v{5}; are un singur element (5), iar std::vector<int> v(5); are cinci elemente egale cu 0.
• Citești un element care nu există, de exemplu v[v.size()] sau v[0] pe un vector gol. Este comportament nedefinit: programul poate afișa valori aleatorii sau se poate opri. Verifică size() sau folosește at().
• Transmiți vectorul unei funcții prin valoare (void f(std::vector<int> v)) și se copiază tot. Folosește const std::vector<int>& când funcția doar citește.

Comenzi înrudite

• std::vector::push_back: Adaugă un element la sfârșitul vectorului; vectorul crește cu o poziție.
• std::vector::size: size() spune câte elemente are vectorul; empty() spune dacă nu are niciunul.
• std::vector::at: Returnează elementul de la o poziție, cu verificare: aruncă std::out_of_range dacă poziția nu există.
• std::vector::operator[]: Accesează elementul de pe o poziție cu v[i], fără verificare a limitelor.
• std::array: Tablou cu dimensiune fixă, cunoscută la compilare, cu interfața unui container (size, at, begin, end).
• std::deque: Coadă cu două capete: adăugare și ștergere rapidă atât la început, cât și la sfârșit, plus acces după poziție.
• std::span: O „fereastră” spre elemente consecutive din memorie (vector, array, tablou C), fără copiere și fără să le dețină.