vector w C++: dynamiczne tablice z std::vector

Dlaczego vector zamiast surowej tablicy

Surowa tablica ma rozmiar ustalony na sztywno w czasie kompilacji i zapomina swoją długość w chwili, gdy przekażesz ją do funkcji. std::vector rozwiązuje oba problemy: to tablica o zmiennym rozmiarze, która śledzi własną długość, rośnie w razie potrzeby i sama sprząta swoją pamięć. We współczesnym C++ vector to kontener domyślny: po surową tablicę sięgaj tylko wtedy, gdy masz konkretny powód.

Dołącz <vector>, a potem zadeklaruj vector z typem elementów w nawiasach ostrych:

#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() zawsze podaje bieżącą długość: nie trzeba osobnego int n do synchronizowania ani sztuczek z sizeof. {90, 75, 100, 60} to inicjalizator klamrowy, a vector sam ustala, że potrzebuje czterech miejsc.

Tworzenie i inicjalizacja vectora

Jest kilka sposobów na zbudowanie vectora, zależnie od tego, co wiesz na starcie:

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

int main() {
    vector<int> empty;                 // 0 elementów
    vector<int> filled = {1, 2, 3};    // 3 elementy z listy
    vector<int> tens(5, 10);           // 5 elementów, każdy = 10
    vector<string> names(3);           // 3 puste napisy

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

Uważaj na pułapkę nawiasów okrągłych i klamrowych: vector<int> tens(5, 10) tworzy pięć kopii 10, a vector<int> tens{5, 10} tworzy dwuelementowy vector z wartościami 5 i 10. Nawiasy okrągłe znaczą "rozmiar i wartość wypełnienia", a klamry "dokładnie te elementy".

Dodawanie i usuwanie elementów

Cały sens vectora polega na tym, że rośnie. push_back dopisuje element na końcu, a pop_back usuwa go z końca:

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

int main() {
    vector<int> v;          // start od pustego
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);

    v.pop_back();           // usuwa 30

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

back() zwraca ostatni element, a front() pierwszy: to czytelniejsze niż v[v.size() - 1] i v[0]. Od C++11 możesz też użyć emplace_back(args...), żeby utworzyć element w miejscu, co przy cięższych typach pozwala uniknąć tymczasowej kopii.

Częsty błąd początkujących to wywołanie front() albo back() na pustym vectorze. To niezdefiniowane zachowanie, a nie błąd: zawsze najpierw zabezpiecz się warunkiem if (!v.empty()).

Odczyt elementów: [] a at()

Vector indeksujesz dokładnie jak tablicę, za pomocą []. Ale [] nie sprawdza zakresu: indeks spoza zakresu to niezdefiniowane zachowanie, które może po cichu odczytać śmieci albo wysypać program później, w mylącym miejscu:

vector<int> v = {1, 2, 3};
cout << v[10];   // NIEZDEFINIOWANE ZACHOWANIE: bez sprawdzenia, bez błędu

Gdy zależy ci na bezpieczeństwie, użyj at(). Sprawdza indeks i przy złym dostępie rzuca std::out_of_range, jeden z wyjątków biblioteki standardowej, które możesz złapać, więc dostajesz wyraźny błąd zamiast uszkodzonych danych:

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

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

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

Praktyczna zasada: używaj [] w ciasnych pętlach, gdzie poprawność indeksu jest już pewna, a at() na granicach, przez które może się prześlizgnąć złe wejście.

Pętla po vectorze

Najczystszy sposób przejścia po vectorze to pętla for po zakresie. Bierz elementy przez const auto&, żeby czytać bez kopiowania, albo przez auto&, żeby edytować je w miejscu:

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

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

    for (auto& n : v) {       // referencja: edytuje prawdziwe elementy
        n *= n;
    }

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

Jeśli naprawdę potrzebujesz indeksu (na przykład do porównywania sąsiadów), użyj klasycznej pętli z licznikiem, ale pamiętaj, że size() zwraca typ bez znaku (size_t). Porównywanie z nim int i ze znakiem może wywołać ostrzeżenia kompilatora i zaskakujące zawijanie wartości, więc gdy tylko się da, wybieraj size_t i albo pętlę po zakresie:

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

size, capacity i reserve

Vector przechowuje dwie liczby: size() (ile elementów zawiera) i capacity() (ile może pomieścić, zanim będzie musiał urosnąć). Gdy push_back przekroczy pojemność, vector alokuje większy blok, kopiuje do niego wszystkie elementy i zwalnia stary blok. Dlatego wielokrotne push_back jest tanie w ujęciu zamortyzowanym, ale każda pojedyncza realokacja coś kosztuje:

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

int main() {
    vector<int> v;
    v.reserve(100);          // rezerwuje z góry miejsce na 100 elementów

    for (int i = 0; i < 100; i++) {
        v.push_back(i);      // bez realokacji: pojemność już jest
    }

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

Jeśli wiesz mniej więcej, ile elementów dodasz, najpierw wywołaj reserve(), żeby pominąć powtarzane realokacje. Zauważ, że reserve() zmienia pojemność, a nie rozmiar: vector nadal ma zero elementów, dopóki ich nie dodasz.

Ta realokacja jest też źródłem najpaskudniejszego błędu z vectorem. Ponieważ wzrost przenosi dane w inne miejsce, każdy zapisany wskaźnik, referencja lub iterator do vectora staje się wiszący po push_back, który wywołał realokację:

vector<int> v = {1, 2, 3};
int& first = v[0];     // referencja do elementu vectora
v.push_back(4);        // może realokować...
cout << first;         // WISZĄCA: może wskazywać na zwolnioną pamięć

To samo dotyczy iteratorów: nie wywołuj push_back ani erase podczas iteracji z zapisanym iteratorem. Jeśli musisz usuwać elementy w pętli, używaj wartości zwracanej przez erase albo idiomu erase-remove z std::remove.

Dalej: map

vector sprawdza się idealnie, gdy szukasz elementów według pozycji: element 0, element 1 i tak dalej. Często jednak chcesz szukać według klucza: nazwy użytkownika, identyfikatora produktu, słowa. Do tego służy std::map. Następnie omówimy map, kontener klucz-wartość w C++, w tym wstawianie, wyszukiwanie i iterowanie po wpisach oraz pułapkę "[] tworzy wartość domyślną", na której potyka się prawie każdy.