Maîtriser std::list en C++ : Syntaxe, Fonctions et Exemples Pratiques

Qu'est-ce que std::list ?

En C++, std::list est un conteneur de séquence qui stocke les éléments sous forme de liste doublement chaînée. Cette structure permet d'insérer ou de supprimer des éléments à n'importe quelle position en temps constant, tout en permettant l'itération dans les deux sens. Bien qu'il n'offre pas d'accès aléatoire rapide comme std::vector, il excelle dans les scénarios nécessitant des insertions ou suppressions fréquentes.

Le conteneur gère automatiquement la mémoire via un allocateur, ce qui lui permet de croître ou de décroître aux deux extrémités pendant l'exécution.

Pourquoi utiliser std::list ?

• Insertion et suppression en temps constant n'importe où dans la séquence.
• Efficace pour les algorithmes qui déplacent fréquemment des éléments.
• Idéal lorsque la taille du conteneur change de manière imprévisible.

Définition d'une liste

Pour utiliser std::list, incluez l'en-tête <list> :

#include <list> // Définition du template
// template<class T, class Alloc = std::allocator<T>> class list;

Paramètres :

• T – Type des éléments stockés. Tout type constructible par copie est autorisé.
• Alloc – Type d'allocateur. L'allocateur par défaut std::allocator suffit généralement.

Exemple 1 : Itération de base

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

Sortie :

Opérations courantes sur std::list

Fonction	Description
insert()	Insère un élément avant la position de l'itérateur.
push_back()	Ajoute un élément à la fin.
push_front()	Ajoute un élément au début.
pop_front()	Supprime le premier élément.
size()	Retourne le nombre d'éléments.
front()	Accède au premier élément.
back()	Accède au dernier élément.
reverse()	Inverse l'ordre des éléments.
merge()	Fusionne deux listes triées en une seule.

Constructeurs

• std::list() – Constructeur par défaut ; crée une liste vide.
• std::list(n) – Constructeur de remplissage ; crée n éléments construits par défaut.
• std::list(first, last) – Constructeur par plage ; copie les éléments d'une autre plage.
• std::list(const list&) – Constructeur de copie.
• std::list(list&&) – Constructeur de déplacement.
• std::list(std::initializer_list<T>) – Constructeur par liste d'initialisation.

Exemple 2 : Variantes de constructeurs

#include <iostream>
#include <list>
int main() {
    std::list<int> l; // vide
    std::list<int> l1{10, 20, 30};
    std::list<int> l2(l1.begin(), l1.end()); // copie par plage
    std::list<int> l3(std::move(l1)); // déplacement
    std::cout << "Taille de l : " << l.size() << '\n';
    std::cout << "Contenu de l2:\n";
    for (int x : l2) std::cout << x << '\n';
    std::cout << "Contenu de l3:\n";
    for (int x : l3) std::cout << x << '\n';
}

Sortie :

Propriétés du conteneur

• Séquence – Les éléments sont stockés dans un ordre linéaire accessible par position.
• Liste doublement chaînée – Chaque nœud connaît son prédécesseur et son successeur, permettant des insertions/suppressions en temps constant.
• Sensible à l'allocateur – Utilise un allocateur pour demander de la mémoire selon les besoins.

Insertion d'éléments

Utilisez push_front, push_back ou insert pour ajouter des éléments.

Exemple 3 : Insertions mixtes

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

Sortie :

Suppression d'éléments

Utilisez erase pour supprimer des éléments uniques ou des plages.

Exemple 4 : Démonstration d'erase

#include <iostream>
#include <list>
int main() {
    std::list<int> my_list{12, 5, 10, 9};
    std::cout << "Avant suppression:\n";
    for (int x : my_list) std::cout << x << '\n';
    my_list.erase(my_list.begin()); // supprime le premier
    std::cout << "Après suppression:\n";
    for (int x : my_list) std::cout << x << '\n';
}

Sortie :

Points clés à retenir

• std::list est un conteneur de séquence à liste doublement chaînée.
• Il offre des insertions/suppressions en temps constant depuis n'importe quelle position.
• Le parcours séquentiel est supporté dans les deux directions.
• L'accès aléatoire n'est pas efficace ; utilisez std::vector lorsque vous avez besoin d'un indexation rapide.
• Les constructeurs, itérateurs et la sensibilité à l'allocateur rendent std::list polyvalent pour les ensembles de données dynamiques.