std:: list
|
Défini dans l'en-tête
<list>
|
||
|
template
<
class
T,
|
(1) | |
|
namespace
pmr
{
template
<
class
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
|
(depuis C++26) |
Table des matières |
Paramètres du modèle
| T | - |
Le type des éléments.
|
||||||||||||||
| 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
|
|
||||
const_pointer
|
|
||||
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) |
|
|
(C++23)
|
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 |
|
|
(C++11)
|
retourne un itérateur vers le début
(fonction membre publique) |
|
(C++11)
|
retourne un itérateur vers la fin
(fonction membre publique) |
|
(C++11)
|
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) |
|
|
(C++23)
|
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) |
|
|
(C++11)
|
construit un élément sur place à la fin
(fonction membre publique) |
|
(C++23)
|
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) |
|
|
(C++11)
|
construit un élément sur place au début
(fonction membre publique) |
|
(C++23)
|
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
|
(C++11)
|
liste simplement chaînée
(modèle de classe) |