C++-Iteratoren erklärt: begin, end und Iteratortypen

Was ein Iterator wirklich ist

Jeder Standardcontainer - vector, string, map, set, list - speichert seine Elemente intern unterschiedlich. Ein vector ist ein zusammenhängender Block, eine map ein balancierter Baum, eine list sind verkettete Knoten. Dennoch kannst du sie alle auf dieselbe Weise durchlaufen. Möglich macht das der Iterator: ein kleines Objekt, das auf ein Element „zeigt" und weiß, wie es zum nächsten weiterschreitet.

Stell dir einen Iterator als verallgemeinerten Zeiger vor. Einen bekommst du mit begin(), das Element, auf das er zeigt, liest du mit *, und mit ++ rückst du ihn vorwärts. Die Teile fügen sich so zusammen:

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

int main() {
    vector<int> v = {10, 20, 30};

    vector<int>::iterator it = v.begin();
    cout << *it << "\n";   // 10 - Dereferenzieren liest das Element

    ++it;                  // rückt zum nächsten Element vor
    cout << *it << "\n";   // 20
}

v.begin() gibt einen Iterator auf das erste Element zurück; *it liefert dir dieses Element; ++it rückt zum nächsten weiter. Dieses Trio - dereferenzieren, vorrücken, vergleichen - ist das gesamte mentale Modell.

begin(), end() und der halboffene Bereich

Die andere Hälfte des Bildes ist end(). Entscheidend: end() zeigt nicht auf das letzte Element - es zeigt auf die Position eine hinter dem letzten Element. Das ist ein bewusst „halboffener" Bereich [begin, end): begin ist eingeschlossen, end ist das Stoppsignal.

Dieser Entwurf macht die Standardschleife sauber - du läufst, bis der Iterator gleich end() ist:

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

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

    for (auto it = v.begin(); it != v.end(); ++it) {
        cout << *it << " ";
    }
    cout << "\n";
}

Beachte it != v.end(), nicht it < v.end(). Die meisten Container-Iteratoren (wie map oder list) unterstützen kein <, nur == und !=, daher ist != die portable Wahl. Und auto erspart dir, vector<int>::iterator von Hand zu schreiben - das Schlüsselwort lässt den Compiler den Typ ableiten.

Der Fall des leeren Containers ergibt sich von selbst: Ist ein Container leer, gilt begin() == end(), sodass der Schleifenrumpf nie ausgeführt wird. Keine Sonderbehandlung nötig.

Niemals end() dereferenzieren

Der häufigste Iterator-Bug ist das Dereferenzieren von end(). Da es eine Position hinter das letzte Element zeigt, liest *v.end() Speicher, der dir nicht gehört - undefiniertes Verhalten, das heißt ein Absturz oder stiller Datenmüll, kein freundlicher Fehler:

vector<int> v = {1, 2, 3};
cout << *v.end();   // UNDEFINIERTES VERHALTEN - end() ist kein Element

Dieselbe Falle trifft Suchfunktionen. std::find gibt end() zurück, wenn der Wert nicht gefunden wird, daher musst du vor dem Dereferenzieren prüfen:

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

int main() {
    vector<int> v = {2, 4, 6, 8};

    auto it = find(v.begin(), v.end(), 5);
    if (it != v.end()) {
        cout << "Found: " << *it << "\n";
    } else {
        cout << "5 is not in the vector\n";   // das hier läuft
    }
}

Vergleiche den zurückgegebenen Iterator immer mit end(), bevor du ihn dereferenzierst. Dieses if zu vergessen ist eine der häufigsten Absturzursachen in Anfänger-STL-Code.

const, cbegin und reverse-Iteratoren

Container geben je nach Bedarf unterschiedliche Iterator-Varianten heraus:

• begin() / end() - normale Lese-/Schreib-Iteratoren (*it = ... funktioniert).
• cbegin() / cend() - const_iterators; du kannst durch sie lesen, das Element aber nicht ändern.
• rbegin() / rend() - reverse-Iteratoren, die von hinten nach vorn laufen; ++ bewegt sich tatsächlich rückwärts.

Reverse-Iteratoren sind die saubere Art, rückwärts zu durchlaufen, ohne fummelige Index-Rechnerei:

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

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

    for (auto it = v.rbegin(); it != v.rend(); ++it) {
        cout << *it << " ";   // 4 3 2 1
    }
    cout << "\n";
}

Bei reverse-Iteratoren schreibst du weiterhin ++it, um voranzukommen - der Iterator behandelt die „rückwärts"-Richtung intern. Verwende cbegin()/cend() (oder eine const-Referenz auf den Container), wenn eine Schleife nur lesen soll, damit der Compiler dich daran hindert, versehentlich zu schreiben.

map-Iteratoren liefern Pairs

Nicht jeder Iterator ist nur eine dünne Hülle um einen Zeiger. Ein std::map-Iterator läuft durch einen Baum, und ihn zu dereferenzieren liefert dir ein Paar aus Schlüssel und Wert, auf das du über ->first und ->second zugreifst (genau wie ein Zeiger unterstützt ein Iterator ->):

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

int main() {
    map<string, int> ages = {{"Ada", 36}, {"Grace", 85}};

    for (auto it = ages.begin(); it != ages.end(); ++it) {
        cout << it->first << " -> " << it->second << "\n";
    }
}

Die bereichsbasierte for-Schleife baut direkt auf begin()/end() auf, daher greifst du für schlichtes Vorwärtsiterieren meist zu ihr. Explizite Iteratoren lohnen sich, wenn du einen Rückwärtsdurchlauf, die Position eines Elements oder das Übergeben eines Bereichs an einen Algorithmus brauchst.

Der große Stolperstein: Iterator-Invalidierung

Das ist die Falle, in die früher oder später jeder tappt. Wenn du die Struktur eines Containers änderst, können bestehende Iteratoren invalidiert werden - sie zeigen auf Speicher, der freigegeben oder verschoben wurde. Einen davon zu verwenden ist undefiniertes Verhalten.

Bei einem vector kann push_back zum Wachsen den gesamten Puffer neu allokieren und damit jeden offenen Iterator invalidieren. Löschen während des Durchlaufens ist noch berüchtigter - das ist ein klassischer Absturz:

vector<int> v = {1, 2, 3, 4};
for (auto it = v.begin(); it != v.end(); ++it) {
    if (*it % 2 == 0)
        v.erase(it);   // BUG - erase invalidiert it, dann ist ++it UB
}

Die Lösung: erase gibt einen gültigen Iterator auf das Element nach dem entfernten zurück. Rücke nur weiter, wenn du nicht gelöscht hast:

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

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

    for (auto it = v.begin(); it != v.end(); ) {
        if (*it % 2 == 0)
            it = v.erase(it);   // erase gibt den nächsten gültigen Iterator zurück
        else
            ++it;               // nur weiterrücken, wenn nichts entfernt wurde
    }

    for (int x : v) cout << x << " ";   // 1 3 5
    cout << "\n";
}

Beachte, dass der for-Kopf kein ++it enthält - der Rumpf entscheidet, ob weitergerückt wird. (In echtem Code erledigt das das erase-remove-Idiom oder std::erase_if aus C++20 in einer Zeile.) Die Merkregel: Jede Operation, die Elemente hinzufügt oder entfernt, kann Iteratoren invalidieren, halte also keinen alten Iterator über eine solche Änderung hinweg fest.

Weiter: Algorithmen

Da du nun einen Bereich als begin/end-Paar beschreiben kannst, hast du die gesamte Bibliothek der STL-Algorithmen freigeschaltet. Funktionen wie sort, find, count und accumulate ist es egal, welchen Container du hast - sie arbeiten auf Iteratorbereichen, sodass derselbe Aufruf bei einem vector, einem Array oder einem Ausschnitt davon funktioniert. Als Nächstes setzen wir diese Iteratoren ein und lassen die Standardbibliothek das Schleifen für dich übernehmen.