Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Invalidazione degli iteratori in C++: il caso di std::vector

Scopri quando una modifica del vettore invalida iteratori, riferimenti e puntatori, incluso l’iteratore di fine, e come usare in sicurezza il risultato di std::find_if.

Versione: ISO C++23; implementation support may vary

Sintassi

// ISO C++23; implementation support may vary
// For v of type const std::vector<int>& and a unary predicate pred:
auto it = std::find_if(v.begin(), v.end(), pred);
const int* result = (it == v.end()) ? nullptr : &*it;

Un iteratore invalidato non si può più usare per percorrere il suo intervallo o accedere a un elemento. Le regole dipendono dal contenitore e dall’operazione. Non dereferenziare, non far avanzare e non confrontare un iteratore invalidato, nemmeno con un end() appena ottenuto.

std::vector::begin() indica il primo elemento, mentre std::vector::end() indica la posizione dopo l’ultimo. In un vettore vuoto coincidono. Gli overload const restituiscono const_iterator, gli altri iterator. std::find_if, da <algorithm>, cerca nell’intervallo semiaperto [v.begin(), v.end()) e restituisce l’iteratore alla prima corrispondenza oppure l’end() fornito. Controlla il risultato prima di dereferenziarlo. Per const std::vector<int>&, &*it produce un puntatore non proprietario const int*; se non c’è corrispondenza, restituisci nullptr. Non usare questo modo di prendere l’indirizzo con std::vector<bool>. Poiché first_even riceve il vettore per riferimento const, accetta anche un vettore temporaneo. Se glielo passi direttamente, l’eventuale puntatore non nullo restituito diventa pendente al termine dell’espressione completa che contiene la chiamata.

Una riallocazione invalida tutti gli iteratori, i riferimenti e i puntatori agli elementi, oltre al vecchio end(). Se reserve(n) termina con successo, rialloca se e solo se n > capacity(), senza modificare size(). Un inserimento senza riallocazione conserva iteratori, riferimenti e puntatori strettamente prima del punto di inserimento; invalida quelli da quel punto in poi, incluso il vecchio end(). Quindi push_back senza riallocazione conserva gli accessi agli elementi esistenti, ma non il vecchio end().

erase invalida iteratori e riferimenti dal punto di rimozione in poi, incluso il vecchio end(). Non usare un puntatore all’elemento rimosso per accedere alla corrispondenza originale. Per continuare a scorrere il vettore, usa l’iteratore restituito da erase: indica l’elemento successivo o il nuovo end(). clear() distrugge tutti gli elementi e invalida tutti gli iteratori, i riferimenti e i puntatori a quegli elementi. Dopo la chiamata, ottieni di nuovo end(). Un const int* non prolunga la vita dell’elemento né lo protegge dalle modifiche del vettore. Dopo un’operazione che invalida il risultato, ripeti la ricerca oppure copia prima il valore, se ti serve solo quello.

Esempi

#include <algorithm>
#include <iostream>
#include <vector>

const int* first_even(const std::vector<int>& v) {
    const auto it = std::find_if(v.begin(), v.end(),
                                 [](int x) { return x % 2 == 0; });
    return it == v.end() ? nullptr : &*it;
}

int main() {
    std::vector<int> v{1, 4, 7};
    v.reserve(4);

    {
        const int* p = first_even(v);
        if (!p) return 1;
        std::cout << *p << '\n';
        v.push_back(6);
        std::cout << *p << '\n';
    }

    v.erase(v.begin() + 1);
    if (const int* p = first_even(v)) {
        std::cout << *p << '\n';
    }

    v.clear();
    if (!first_even(v)) {
        std::cout << "no match\n";
    }
}

Risultato

4
4
6
no match

`reserve(4)` lascia spazio per aggiungere `6`: il puntatore a `4` rimane valido, ma il vecchio `end()` no. Dopo la rimozione di `4`, una nuova ricerca trova `6`; dopo `clear()`, non ci sono corrispondenze.

Lezioni correlate

  • C++ · Lezione 10 · Avanzato · Versione: 3

Fonti