std::list in C++ meistern: Syntax, Funktionen & praktische Beispiele

Was ist std::list?

In C++ ist std::list ein Sequenzcontainer, der Elemente als doppelt verkettete Liste speichert. Diese Struktur ermöglicht das Einfügen oder Entfernen von Elementen an beliebiger Position in konstanter Zeit, während eine Iteration in beide Richtungen möglich ist. Obwohl kein schneller wahlfreier Zugriff wie bei std::vector geboten wird, glänzt std::list in Szenarien mit häufigen Einfügungen oder Löschungen.

Der Container verwaltet den Speicher automatisch über einen Allokator, sodass er zur Laufzeit an beiden Enden wachsen oder schrumpfen kann.

Warum std::list verwenden?

• Konstantzeit-Einfügung und -Löschung an jeder Stelle der Sequenz.
• Effizient für Algorithmen, die Elemente häufig verschieben.
• Ideal, wenn sich die Containergröße unvorhersehbar ändert.

Eine Liste definieren

Zur Nutzung von std::list muss der Header <list> eingebunden werden:

#include <list> // Template-Definition
// template<class T, class Alloc = std::allocator<T>> class list;

Parameter:

• T – Typ der gespeicherten Elemente. Jeder kopierkonstruierbare Typ ist erlaubt.
• Alloc – Allokatortyp. Der Standard std::allocator genügt meist.

Beispiel 1: Grundlegende Iteration

#include <iostream>
#include <list>
int main() {
    std::list<int> my_list{12, 5, 10, 9};
    for (int x : my_list) {
        std::cout << x << '\n';
    }
}

Ausgabe:

Häufige std::list-Operationen

Funktion	Beschreibung
insert()	Fügt ein Element vor der Iterator-Position ein.
push_back()	Fügt ein Element am Ende an.
push_front()	Fügt ein Element am Anfang an.
pop_front()	Entfernt das erste Element.
size()	Gibt die Anzahl der Elemente zurück.
front()	Zugriff auf das erste Element.
back()	Zugriff auf das letzte Element.
reverse()	Kehrt die Reihenfolge der Elemente um.
merge()	Führt zwei sortierte Listen zusammen.

Konstruktoren

• std::list() – Standardkonstruktor; erstellt eine leere Liste.
• std::list(n) – Füllkonstruktor; erstellt n default-konstruierte Elemente.
• std::list(first, last) – Bereichskonstruktor; kopiert Elemente aus einem anderen Bereich.
• std::list(const list&) – Kopierkonstruktor.
• std::list(list&&) – Move-Konstruktor.
• std::list(std::initializer_list<T>) – Initialisiererlisten-Konstruktor.

Beispiel 2: Konstruktor-Varianten

#include <iostream>
#include <list>
int main() {
    std::list<int> l; // leer
    std::list<int> l1{10, 20, 30};
    std::list<int> l2(l1.begin(), l1.end()); // Bereichskopie
    std::list<int> l3(std::move(l1)); // Move
    std::cout << "Größe von l: " << l.size() << '\n';
    std::cout << "Inhalt von l2:\n";
    for (int x : l2) std::cout << x << '\n';
    std::cout << "Inhalt von l3:\n";
    for (int x : l3) std::cout << x << '\n';
}

Ausgabe:

Containereigenschaften

• Sequenz – Elemente liegen in linearer Reihenfolge vor, zugänglich per Position.
• Doppelt verkettet – Jeder Knoten kennt Vorgänger und Nachfolger, was konstante Einfügungen/Löschungen ermöglicht.
• Allokator-bewusst – Nutzt einen Allokator, um Speicher bei Bedarf anzufordern.

Elemente einfügen

Verwenden Sie push_front, push_back oder insert, um Elemente hinzuzufügen.

Beispiel 3: Gemischte Einfügungen

#include <algorithm>
#include <iostream>
#include <list>
int main() {
    std::list<int> my_list{12, 5, 10, 9};
    my_list.push_front(11); // vorne
    my_list.push_back(18);  // hinten
    auto it = std::find(my_list.begin(), my_list.end(), 10);
    if (it != my_list.end()) {
        my_list.insert(it, 21); // vor 10
    }
    for (int x : my_list) std::cout << x << '\n';
}

Ausgabe:

Elemente löschen

Mit erase lassen sich einzelne Elemente oder Bereiche entfernen.

Beispiel 4: Erase-Demonstration

#include <iostream>
#include <list>
int main() {
    std::list<int> my_list{12, 5, 10, 9};
    std::cout << "Vor dem Löschen:\n";
    for (int x : my_list) std::cout << x << '\n';
    my_list.erase(my_list.begin()); // erstes Element entfernen
    std::cout << "Nach dem Löschen:\n";
    for (int x : my_list) std::cout << x << '\n';
}

Ausgabe:

Wichtigste Erkenntnisse

• std::list ist ein doppelt verketteter Sequenzcontainer.
• Er bietet konstantzeitige Einfügungen/Löschungen an beliebiger Position.
• Sequentielle Traversierung wird in beide Richtungen unterstützt.
• Wahlfreier Zugriff ist nicht effizient; nutzen Sie std::vector für schnelles Indexieren.
• Konstruktoren, Iteratoren und Allokator-Bewusstsein machen std::list vielseitig für dynamische Datensätze.