Namespaces
Variants

std:: list

From cppreference.net
Défini dans l'en-tête <list>
template <

class T,
class Allocator = std:: allocator < T >

> class list ;
(1)
namespace pmr {

template < class T >
using list = std :: list < T, std:: pmr :: polymorphic_allocator < T >> ;

}
(2) (depuis C++17)

std::list est un conteneur qui prend en charge l'insertion et la suppression d'éléments en temps constant depuis n'importe où dans le conteneur. L'accès aléatoire rapide n'est pas pris en charge. Il est généralement implémenté comme une liste doublement chaînée. Comparé à std::forward_list ce conteneur offre une capacité d'itération bidirectionnelle tout en étant moins efficace en termes d'utilisation de l'espace.

L'ajout, la suppression et le déplacement des éléments au sein de la liste ou entre plusieurs listes n'invalident pas les itérateurs ni les références. Un itérateur n'est invalidé que lorsque l'élément correspondant est supprimé.

std::list satisfait aux exigences de Container , AllocatorAwareContainer , SequenceContainer et ReversibleContainer .

Toutes les fonctions membres de std::list sont constexpr : il est possible de créer et d'utiliser des objets std::list dans l'évaluation d'une expression constante.

Cependant, les objets std::list ne peuvent généralement pas être constexpr , car toute mémoire allouée dynamiquement doit être libérée dans la même évaluation d'expression constante.

(depuis C++26)

Table des matières

Paramètres du modèle

T - Le type des éléments.
T doit satisfaire aux exigences de CopyConstructible . T doit satisfaire aux exigences de CopyAssignable si list::operator= ou list::assign est instancié avec T . (jusqu'à C++11)
Les exigences imposées aux éléments dépendent des opérations effectivement réalisées sur le conteneur. Généralement, il est requis que le type d'élément soit un type complet et satisfasse aux exigences de Erasable , mais de nombreuses fonctions membres imposent des exigences plus strictes. (depuis C++11)
(jusqu'à C++17)

Les exigences imposées aux éléments dépendent des opérations effectivement réalisées sur le conteneur. Généralement, il est requis que le type d'élément satisfasse aux exigences de Erasable , mais de nombreuses fonctions membres imposent des exigences plus strictes. Ce conteneur (mais pas ses membres) peut être instancié avec un type d'élément incomplet si l'allocateur satisfait aux exigences de complétude de l'allocateur .

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_incomplete_container_elements 201505L (C++17) Support minimal des types incomplets
(depuis C++17)

Allocator - Un allocateur utilisé pour acquérir/libérer la mémoire et pour construire/détruire les éléments dans cette mémoire. Le type doit satisfaire aux exigences de Allocator . Le comportement est indéfini (jusqu'à C++20) Le programme est mal formé (depuis C++20) si Allocator::value_type n'est pas le même que T .

Types membres

Type de membre Définition
value_type T
allocator_type Allocator
size_type Type entier non signé (généralement std::size_t )
difference_type Type entier signé (généralement std::ptrdiff_t )
reference value_type &
const_reference const value_type &
pointer

Allocator::pointer

(jusqu'en C++11)

std:: allocator_traits < Allocator > :: pointer

(depuis C++11)
const_pointer

Allocator::const_pointer

(jusqu'en C++11)

std:: allocator_traits < Allocator > :: const_pointer

(depuis C++11)
iterator LegacyBidirectionalIterator et ConstexprIterator (depuis C++26) vers value_type
const_iterator LegacyBidirectionalIterator et ConstexprIterator (depuis C++26) vers const value_type
reverse_iterator std:: reverse_iterator < iterator >
const_reverse_iterator std:: reverse_iterator < const_iterator >

Fonctions membres

construit la list
(fonction membre publique)
détruit la list
(fonction membre publique)
assigne des valeurs au conteneur
(fonction membre publique)
assigne des valeurs au conteneur
(fonction membre publique)
assigne une plage de valeurs au conteneur
(fonction membre publique)
retourne l'allocateur associé
(fonction membre publique)
Accès aux éléments
accéder au premier élément
(fonction membre publique)
accéder au dernier élément
(fonction membre publique)
Itérateurs
retourne un itérateur vers le début
(fonction membre publique)
(C++11)
retourne un itérateur vers la fin
(fonction membre publique)
retourne un itérateur inverse vers le début
(fonction membre publique)
(C++11)
retourne un itérateur inverse vers la fin
(fonction membre publique)
Capacité
vérifie si le conteneur est vide
(fonction membre publique)
retourne le nombre d'éléments
(fonction membre publique)
retourne le nombre maximum possible d'éléments
(fonction membre publique)
Modificateurs
efface le contenu
(fonction membre publique)
insère des éléments
(fonction membre publique)
insère une plage d'éléments
(fonction membre publique)
(C++11)
construit un élément en place
(fonction membre publique)
efface les éléments
(fonction membre publique)
ajoute un élément à la fin
(fonction membre publique)
construit un élément sur place à la fin
(fonction membre publique)
ajoute une plage d'éléments à la fin
(fonction membre publique)
supprime le dernier élément
(fonction membre publique)
insère un élément au début
(fonction membre publique)
construit un élément sur place au début
(fonction membre publique)
ajoute une plage d'éléments au début
(fonction membre publique)
supprime le premier élément
(fonction membre publique)
modifie le nombre d'éléments stockés
(fonction membre publique)
échange le contenu
(fonction membre publique)
Opérations
fusionne deux listes triées
(fonction membre publique)
transfère des éléments d'une autre list
(fonction membre publique)
supprime les éléments satisfaisant des critères spécifiques
(fonction membre publique)
inverse l'ordre des éléments
(fonction membre publique)
supprime les éléments dupliqués consécutifs
(fonction membre publique)
trie les éléments
(fonction membre publique)

Fonctions non membres

(supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (supprimé en C++20) (C++20)
compare lexicographiquement les valeurs de deux list s
(modèle de fonction)
spécialise l'algorithme std::swap
(modèle de fonction)
efface tous les éléments satisfaisant des critères spécifiques
(modèle de fonction)

Guides de déduction

(depuis C++17)

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_containers_ranges 202202L (C++23) Construction et insertion de gammes pour les conteneurs
__cpp_lib_constexpr_list 202502L (C++26) constexpr std::list

Exemple

#include <algorithm>
#include <iostream>
#include <list>
int main()
{
    // Créer une liste contenant des entiers
    std::list<int> l = {7, 5, 16, 8};
    // Ajouter un entier au début de la liste
    l.push_front(25);
    // Ajouter un entier à la fin de la liste
    l.push_back(13);
    // Insérer un entier avant 16 en effectuant une recherche
    auto it = std::find(l.begin(), l.end(), 16);
    if (it != l.end())
        l.insert(it, 42);
    // Afficher la liste
    std::cout << "l = { ";
    for (int n : l)
        std::cout << n << ", ";
    std::cout << "};\n";
}

Sortie :

l = { 25, 7, 5, 42, 16, 8, 13, };

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 230 C++98 T n'était pas requis d'être CopyConstructible
(un élément de type T pourrait ne pas pouvoir être construit)
T est également requis
d'être CopyConstructible
LWG 276 C++98 T était toujours requis d'être CopyAssignable requis uniquement si operator= ou
assign est instancié avec T

Voir aussi

liste simplement chaînée
(modèle de classe)