Beheersen van std::list in C++: Syntaxis, Functies & Praktische Voorbeelden

Wat is std::list?

In C++ is std::list een sequentiecontainer die elementen opslaat als een dubbel gelinkte lijst. Deze structuur stelt je in staat om items op elke positie in constante tijd in te voegen of te verwijderen, terwijl je in beide richtingen over de lijst kunt itereren. Hoewel het geen snelle willekeurige toegang biedt zoals std::vector, uitblinkt het in scenario's waar frequente invoegingen of verwijderingen plaatsvinden.

De container beheert geheugen automatisch via een allocator, zodat deze tijdens runtime aan beide kanten kan groeien of krimpen.

Waarom std::list gebruiken?

• Constante-tijd invoeging en verwijdering op elke positie in de sequentie.
• Efficiënt voor algoritmen die elementen vaak verplaatsen.
• Ideaal wanneer de grootte van de container onvoorspelbaar verandert.

Een lijst definiëren

Om std::list te gebruiken, neem je de <list> header op:

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

Parameters:

• T – Type van de opgeslagen elementen. Elk kopieerbaar type is toegestaan.
• Alloc – Allocatortype. De standaard std::allocator is meestal voldoende.

Voorbeeld 1: Basisiteratie

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

Uitvoer:

Algemene std::list-bewerkingen

Constructors

• std::list() – Standaardconstructor; maakt een lege lijst.
• std::list(n) – Vulconstructor; maakt n standaard-geconstrueerde elementen.
• std::list(first, last) – Bereikconstructor; kopieert elementen uit een ander bereik.
• std::list(const list&) – Kopieerconstructor.
• std::list(list&&) – Verhuisconstructor.
• std::list(std::initializer_list<T>) – Initialisatielijst-constructor.

Voorbeeld 2: Constructor-varianten

#include <iostream>
#include <list>
int main() {
    std::list<int> l; // leeg
    std::list<int> l1{10, 20, 30};
    std::list<int> l2(l1.begin(), l1.end()); // bereik kopiëren
    std::list<int> l3(std::move(l1)); // verplaatsen
    std::cout << "Grootte van l: " << l.size() << '\n';
    std::cout << "Inhoud van l2:\n";
    for (int x : l2) std::cout << x << '\n';
    std::cout << "Inhoud van l3:\n";
    for (int x : l3) std::cout << x << '\n';
}

Uitvoer:

Containereigenschappen

• Sequentieel – Elementen zijn in lineaire volgorde opgeslagen, toegankelijk per positie.
• Dubbel gelinkte lijst – Elk knooppunt kent zijn voorganger en opvolger, wat constantetijd invoegingen/verwijderingen mogelijk maakt.
• Allocator-bewust – Gebruikt een allocator om geheugen op te vragen wanneer nodig.

Elementen invoegen

Gebruik push_front, push_back of insert om items toe te voegen.

Voorbeeld 3: Gemengde invoegingen

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

Uitvoer:

Elementen verwijderen

Gebruik erase om enkele elementen of bereiken te verwijderen.

Voorbeeld 4: Erase-demonstratie

#include <iostream>
#include <list>
int main() {
    std::list<int> my_list{12, 5, 10, 9};
    std::cout << "Voor verwijdering:\n";
    for (int x : my_list) std::cout << x << '\n';
    my_list.erase(my_list.begin()); // verwijder eerste
    std::cout << "Na verwijdering:\n";
    for (int x : my_list) std::cout << x << '\n';
}

Uitvoer:

Belangrijkste punten

• std::list is een dubbel gelinkte sequentiecontainer.
• Het biedt constantetijd invoegingen/verwijderingen vanaf elke positie.
• Sequentiële doorloop wordt in beide richtingen ondersteund.
• Willekeurige toegang is niet efficiënt; gebruik std::vector als je snelle indexering nodig hebt.
• Constructors, iteratoren en allocator-bewustzijn maken std::list veelzijdig voor dynamische datasets.