WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Iteratorinvalidierung in C++ am Beispiel von std::vector

Wann Änderungen an einem Vektor Iteratoren, Referenzen und Zeiger ungültig machen, warum auch end() betroffen ist und wie sich das Ergebnis von std::find_if sicher nutzen lässt.

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

Syntax

// 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;

Wird ein Iterator ungültig, lässt er sich nicht mehr zum Durchlaufen seines Bereichs oder zum Zugriff auf ein Element verwenden. Die Regeln hängen vom Container und von der Operation ab. Einen ungültigen Iterator weder dereferenzieren noch weiterschalten oder vergleichen, auch nicht mit einem neu abgefragten end().

std::vector::begin() bezeichnet das erste Element, std::vector::end() die Position hinter dem letzten Element. Bei einem leeren Vektor sind beide gleich. Die const-Überladungen liefern const_iterator, die übrigen iterator. std::find_if aus <algorithm> durchsucht den halboffenen Bereich [v.begin(), v.end()) und liefert den Iterator zum ersten Treffer oder das übergebene end(). Prüfe das Ergebnis vor dem Dereferenzieren. Für const std::vector<int>& liefert &*it einen nicht besitzenden const int*; ohne Treffer gib nullptr zurück. Verwende dieses Muster zur Adressbildung nicht für std::vector<bool>. Da first_even den Vektor per const-Referenz entgegennimmt, kannst du auch einen temporären Vektor übergeben. Übergibst du ihn direkt, wird ein zurückgegebener Zeiger ungleich nullptr am Ende des vollständigen Ausdrucks, der den Aufruf enthält, ungültig.

Eine Reallokation macht alle Iteratoren, Referenzen und Zeiger auf Elemente sowie das alte end() ungültig. Ein erfolgreicher Aufruf von reserve(n) reallokiert genau dann, wenn n > capacity() gilt; size() bleibt gleich. Beim Einfügen ohne Reallokation bleiben Iteratoren, Referenzen und Zeiger vor der Einfügeposition gültig. Ab dieser Position werden sie ungültig, einschließlich des alten end(). Bei push_back ohne Reallokation bleiben daher die Zugriffe auf bisherige Elemente gültig, nicht aber das alte end().

erase macht Iteratoren und Referenzen ab der Löschposition ungültig, einschließlich des alten end(). Greife nicht über einen Zeiger auf das entfernte Element auf den ursprünglichen Treffer zu. Setze die Iteration mit dem von erase gelieferten Iterator fort: Er bezeichnet das nächste Element oder das neue end(). clear() zerstört alle Elemente und macht damit alle Iteratoren, Referenzen und Zeiger auf Elemente ungültig. Frage end() danach neu ab. Ein const int* verlängert weder die Lebensdauer des Elements noch schützt er es vor Änderungen am Vektor. Suche nach einer invalidierenden Operation erneut oder kopiere vorher den Wert, wenn du nur diesen brauchst.

Beispiele

#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";
    }
}

Ergebnis

4
4
6
no match

`reserve(4)` schafft Platz zum Anhängen von `6`: Der Zeiger auf `4` bleibt gültig, das alte `end()` nicht. Nach dem Entfernen von `4` findet eine neue Suche `6`; nach `clear()` gibt es keinen Treffer.

Zugehörige Lektionen

  • C++ · Lektion 10 · Fortgeschritten · Version: 3

Quellen