Entfernen eines Elements aus einem Vektor per Index: Anatomie von std::vector::erase

Wie man ein Element aus std::vector per Index löscht: Ein Blick unter die Haube

Hallo, Kollege! Wenn du jemals in C++ programmiert und mit dynamischen Arrays gearbeitet hast, bist du bestimmt auf die Frage gestoßen: "How do I erase an element from std::vector<> by index?" – das ist eine der häufigsten Anfragen auf Stack Overflow, und das aus gutem Grund. Auf den ersten Blick scheint die Aufgabe trivial: erase aufrufen – und fertig. Aber was passiert eigentlich im Speicher? Warum ist das Löschen aus der Mitte des Vektors teuer? Und wie vermeidet man Fallstricke mit Iteratoren?

In diesem Artikel zeigen wir nicht nur, wie man v.erase(v.begin() + index) schreibt. Wir werden verstehen, wie diese Operation unter der Haube funktioniert, welche Datenstrukturen beteiligt sind und wie man die optimale Löschmethode auswählt. Los geht's!

1. std::vector: Was ist das für ein Tier?

Bevor wir löschen, erinnern wir uns daran, wie std::vector aufgebaut ist. Es ist ein dynamisches Array, das Elemente in einem zusammenhängenden Speicherbereich speichert. Es hat drei wichtige Zeiger (oder Iteratoren):

\n
• begin – Anfang des reservierten Speichers;
\n
• end – Ende des belegten Speichers (hinter dem letzten Element);
\n
• capacity – Ende des reservierten Speichers (Grenze, bis zu der ohne Neuzuweisung gewachsen werden kann).
\n

Visuell sieht das so aus:

[0] [1] [2] [3] [4] ... [capacity-1]\n ^                        ^\n begin                   end\n

Wenn du ein Element aus der Mitte löscht, wirft der Vektor es nicht einfach "raus" – er verschiebt physisch alle nachfolgenden Elemente nach links. Das ist der Haupt-"Schmerz" der erase-Operation.

2. Löschen per Index: Grundlegende Syntax

Der einfachste Weg, ein Element per Index zu löschen, ist die Verwendung der Methode erase mit einem Iterator:

#include <vector>\n#include <iostream>\n\nint main() {\n    std::vector<int> v = {10, 20, 30, 40, 50};\n    int index = 2; // wir wollen das dritte Element löschen (30)\n\n    // Prüfen, ob der Index innerhalb der Grenzen liegt\n    if (index < v.size()) {\n        v.erase(v.begin() + index);\n    }\n\n    for (int x : v) std::cout << x << " ";\n    // Ausgabe: 10 20 40 50\n    return 0;\n}\n

Ganz einfach, oder? Aber was, wenn man mehrere aufeinanderfolgende Elemente löschen muss? Dafür gibt es die Überladung erase(first, last):

v.erase(v.begin() + 1, v.begin() + 3); // löscht Elemente mit den Indizes 1 und 2\n

3. Und was ist unter der Haube? Detaillierte Analyse

Jetzt kommt der interessanteste Teil. Wenn du v.erase(iterator) aufrufst, passiert intern Folgendes:

\n
1. Iterator-Prüfung (im Debug-Modus) – wir stellen sicher, dass er gültig ist und auf ein Element des Vektors zeigt.
\n
2. Verschieben der Elemente – alle Elemente nach dem zu löschenden werden um eine Position nach links kopiert (oder verschoben, wenn der Typ Move-Semantik unterstützt).
\n
3. Verkleinern der Größe – der interne Zähler size wird um 1 verringert.
\n
4. Destruktor – für das "Schwanz"-Element (das jetzt dupliziert ist) wird der Destruktor aufgerufen (wenn der Typ nicht trivial ist).
\n

Schauen wir uns eine vereinfachte Implementierung an (Pseudocode):

template<typename T>\ntypename std::vector<T>::iterator\nvector<T>::erase(iterator pos) {\n    // 1. Alle Elemente nach pos um eine Position nach links verschieben\n    for (auto it = pos; it != end() - 1; ++it) {\n        *it = std::move(*(it + 1));\n    }\n    // 2. Größe verringern\n    --size;\n    // 3. Destruktor für das letzte Element aufrufen\n    allocator.destroy(end()); // end() zeigt jetzt auf das ehemalige letzte Element\n    return pos; // Iterator auf das Element nach dem gelöschten zurückgeben\n}\n

Beachte std::move – modernes C++ versucht, unnötige Kopien zu vermeiden.