Vector in C++: array dinamici con std::vector spiegati

Perché vector invece di un array grezzo

Un array grezzo ha una dimensione fissa stabilita in fase di compilazione e si dimentica quanto è lungo nel momento in cui lo passi a una funzione. std::vector risolve entrambi i problemi: è un array ridimensionabile che tiene traccia della propria lunghezza, cresce quando serve e libera da solo la propria memoria. Nel C++ moderno vector è il contenitore di default: usa un array grezzo solo quando hai un motivo preciso per non usarlo.

Includi <vector>, poi dichiaralo con il tipo degli elementi tra parentesi angolari:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> scores = {90, 75, 100, 60};

    cout << "Count: " << scores.size() << "\n";
    cout << "First: " << scores[0] << "\n";
}

scores.size() ti dice sempre la lunghezza attuale: nessun int n separato da tenere allineato e nessun trucco con sizeof. {90, 75, 100, 60} è un inizializzatore con graffe; il vector capisce da solo che gli servono quattro posti.

Creare e inizializzare un vector

Ci sono diversi modi per costruirne uno, a seconda di cosa sai in partenza:

#include <iostream>
#include <string>
#include <vector>
using namespace std;

int main() {
    vector<int> empty;                 // 0 elementi
    vector<int> filled = {1, 2, 3};    // 3 elementi da un elenco
    vector<int> tens(5, 10);           // 5 elementi, ognuno = 10
    vector<string> names(3);           // 3 stringhe vuote

    cout << empty.size() << " "
         << filled.size() << " "
         << tens.size() << " "
         << names.size() << "\n";      // 0 3 5 3
}

Attenzione alla trappola tonde contro graffe: vector<int> tens(5, 10) crea cinque copie di 10, mentre vector<int> tens{5, 10} crea un vector di due elementi che contiene 5 e 10. Le parentesi tonde significano "dimensione e valore di riempimento"; le graffe significano "proprio questi elementi".

Aggiungere e rimuovere elementi

Il senso di un vector è proprio che cresce. push_back aggiunge in fondo e pop_back rimuove dal fondo:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> v;          // parte vuoto
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);

    v.pop_back();           // toglie il 30

    cout << "Size: " << v.size() << "\n";   // 2
    cout << "Back: " << v.back() << "\n";    // 20
}

back() restituisce l'ultimo elemento e front() il primo, in modo più pulito di v[v.size() - 1] e v[0]. Da C++11 puoi anche usare emplace_back(args...) per costruire un elemento sul posto, evitando una copia temporanea per i tipi più pesanti.

Un errore comune da principianti è chiamare front() o back() su un vector vuoto. È undefined behavior, non un errore segnalato: proteggiti sempre prima con if (!v.empty()).

Leggere gli elementi: [] e at()

Accedi a un vector con [] esattamente come a un array. Ma [] non fa alcun controllo sui limiti: un indice fuori intervallo è undefined behavior, che può leggere spazzatura in silenzio o crashare più tardi in un punto che confonde:

vector<int> v = {1, 2, 3};
cout << v[10];   // UNDEFINED BEHAVIOR: nessun controllo, nessun errore

Quando vuoi sicurezza, usa at(). Controlla l'indice e lancia std::out_of_range in caso di accesso errato, una delle eccezioni della libreria standard che puoi catturare, così ottieni un errore chiaro invece di una corruzione:

#include <iostream>
#include <stdexcept>
#include <vector>
using namespace std;

int main() {
    vector<int> v = {1, 2, 3};

    try {
        cout << v.at(10) << "\n";   // lancia out_of_range
    } catch (const out_of_range& e) {
        cout << "Caught: " << e.what() << "\n";
    }
}

Regola pratica: usa [] nei cicli stretti in cui hai già dimostrato che l'indice è valido, e at() ai confini in cui potrebbe infilarsi un input sbagliato.

Scorrere un vector

Il modo più pulito per scorrere un vector è il ciclo for basato su intervallo. Prendi gli elementi come const auto& per leggerli senza copiarli, oppure come auto& per modificarli sul posto:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> v = {1, 2, 3, 4};

    for (auto& n : v) {       // riferimento: modifica gli elementi reali
        n *= n;
    }

    for (const auto& n : v) { // sola lettura
        cout << n << " ";     // 1 4 9 16
    }
    cout << "\n";
}

Se ti serve davvero l'indice (per confrontare elementi vicini, ad esempio), usa un classico ciclo con contatore, ma nota che size() restituisce un tipo senza segno (size_t). Confrontarlo con un int i con segno può generare avvisi del compilatore e ritorni a capo sorprendenti, quindi quando puoi preferisci size_t i o un ciclo basato su intervallo:

for (size_t i = 0; i < v.size(); i++) {   // size_t, non int
    cout << v[i];
}

size, capacity e reserve

Un vector tiene due numeri: size() (quanti elementi contiene) e capacity() (quanti ne può contenere prima di dover crescere). Quando un push_back supera la capacità, il vector alloca un blocco più grande, ci copia ogni elemento e libera il vecchio blocco. Ecco perché una serie di push_back costa poco in media, ma ogni singola riallocazione non è gratis:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> v;
    v.reserve(100);          // prealloca spazio per 100

    for (int i = 0; i < 100; i++) {
        v.push_back(i);      // nessuna riallocazione: la capacità c'è già
    }

    cout << "Size: " << v.size() << ", capacity >= " << v.capacity() << "\n";
}

Se sai più o meno quanti elementi aggiungerai, chiama prima reserve() per evitare le riallocazioni ripetute. Nota che reserve() cambia la capacità, non la dimensione: il vector ha ancora zero elementi finché non li aggiungi.

Questa riallocazione è anche la fonte del bug più subdolo dei vector. Dato che la crescita sposta lo spazio in memoria, qualsiasi puntatore, riferimento o iteratore che hai salvato nel vector diventa pendente dopo un push_back che rialloca:

vector<int> v = {1, 2, 3};
int& first = v[0];     // riferimento dentro il vector
v.push_back(4);        // può riallocare...
cout << first;         // PENDENTE: può puntare a memoria liberata

Lo stesso vale per gli iteratori: non fare push_back o erase mentre iteri con un iteratore salvato. Se devi rimuovere elementi durante un ciclo, usa il valore restituito da erase, oppure l'idioma erase-remove con std::remove.

Prossimo: map

Un vector è perfetto quando cerchi le cose per posizione: elemento 0, elemento 1 e così via. Ma spesso vuoi invece cercarle tramite una chiave: un nome utente, l'ID di un prodotto, una parola. A questo serve std::map. Adesso vedremo map, il contenitore chiave-valore del C++, compreso come inserire, cercare e scorrere gli elementi, e l'insidia di [] che crea un valore predefinito e che fa inciampare quasi tutti.