std:: forward_list

Défini dans l'en-tête <forward_list>
template < class T, class Allocator = std:: allocator < T > > class forward_list ;	(1)	(depuis C++11)
namespace pmr { template < class T > using forward_list = std :: forward_list < T, std:: pmr :: polymorphic_allocator < T >> ; }	(2)	(depuis C++17)

std::forward_list est un conteneur qui prend en charge l'insertion et la suppression rapides d'éléments depuis n'importe où dans le conteneur. L'accès aléatoire rapide n'est pas pris en charge. Il est implémenté sous forme de liste simplement chaînée. Comparé à std::list ce conteneur offre un stockage plus efficace en espace mémoire lorsque l'itération bidirectionnelle n'est pas nécessaire.

L'ajout, la suppression et le déplacement des éléments dans la liste, ou entre plusieurs listes, n'invalident pas les itérateurs faisant actuellement référence à d'autres éléments de la liste. Cependant, un itérateur ou une référence se rapportant à un élément est invalidé lorsque l'élément correspondant est supprimé (via erase_after ) de la liste.

std::forward_list satisfait aux exigences de Container (à l'exception de la fonction membre size et du fait que la complexité de operator== est toujours linéaire), AllocatorAwareContainer et SequenceContainer .

Toutes les fonctions membres de std::forward_list sont constexpr : il est possible de créer et d'utiliser des objets std::forward_list dans l'évaluation d'une expression constante. Cependant, std::forward_list ne peuvent généralement pas être constexpr , car toute allocation dynamique de mémoire doit être libérée dans la même évaluation d'expression constante.

(depuis C++26)

Table des matières 1 Paramètres du modèle 2 Types membres 3 Fonctions membres 3.1 Accès aux éléments 3.2 Itérateurs 3.3 Capacité 3.4 Modificateurs 3.5 Opérations 4 Fonctions non membres 5 Guides de déduction 6 Notes 7 Exemple 8 Voir aussi

Paramètres du modèle

T	-	Le type des éléments. 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. (jusqu'en 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'en C++20) Le programme est mal formé (depuis C++20) si Allocator::value_type n'est pas identique à 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	std:: allocator_traits < Allocator > :: pointer
const_pointer	std:: allocator_traits < Allocator > :: const_pointer
iterator	LegacyForwardIterator et ConstexprIterator (depuis C++26) vers value_type
const_iterator	LegacyForwardIterator et ConstexprIterator (depuis C++26) vers const value_type

Fonctions membres

(constructeur)	construit le forward_list (fonction membre publique)
(destructor)	détruit le forward_list (fonction membre publique)
operator=	assigne des valeurs au conteneur (fonction membre publique)
assign	assigne des valeurs au conteneur (fonction membre publique)
assign_range (C++23)	assigne une plage de valeurs au conteneur (fonction membre publique)
get_allocator	retourne l'allocateur associé (fonction membre publique)
Accès aux éléments
front	accéder au premier élément (fonction membre publique)
Itérateurs
before_begin cbefore_begin	retourne un itérateur vers l'élément précédant le début (fonction membre publique)
begin cbegin	retourne un itérateur vers le début (fonction membre publique)
end cend	retourne un itérateur vers la fin (fonction membre publique)
Capacité
empty	vérifie si le conteneur est vide (fonction membre publique)
max_size	retourne le nombre maximum possible d'éléments (fonction membre publique)
Modificateurs
clear	efface le contenu (fonction membre publique)
insert_after	insère des éléments après un élément (fonction membre publique)
emplace_after	construit des éléments en place après un élément (fonction membre publique)
insert_range_after (C++23)	insère une plage d'éléments après un élément (fonction membre publique)
erase_after	efface un élément après un élément (fonction membre publique)
push_front	insère un élément au début (fonction membre publique)
emplace_front	construit un élément sur place au début (fonction membre publique)
prepend_range (C++23)	ajoute une plage d'éléments au début (fonction membre publique)
pop_front	supprime le premier élément (fonction membre publique)
resize	modifie le nombre d'éléments stockés (fonction membre publique)
swap	échange le contenu (fonction membre publique)
Opérations
merge	fusionne deux listes triées (fonction membre publique)
splice_after	transfère les éléments d'un autre forward_list (fonction membre publique)
remove remove_if	supprime les éléments satisfaisant des critères spécifiques (fonction membre publique)
reverse	inverse l'ordre des éléments (fonction membre publique)
unique	supprime les éléments dupliqués consécutifs (fonction membre publique)
sort	trie les éléments (fonction membre publique)

Fonctions non membres

operator== operator!= operator< operator<= operator> operator>= operator<=> (C++11) (C++11) (supprimé en C++20) (C++11) (supprimé en C++20) (C++11) (supprimé en C++20) (C++11) (supprimé en C++20) (C++11) (supprimé en C++20) (C++20)	compare lexicographiquement les valeurs de deux forward_list (modèle de fonction)
std::swap (std::forward_list) (C++11)	spécialise l'algorithme std::swap (modèle de fonction)
erase (std::forward_list) erase_if (std::forward_list) (C++20)	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 plages pour les conteneurs
__cpp_lib_constexpr_forward_list	202502L	(C++26)	constexpr std::forward_list

Exemple

Cette section est incomplète Raison : aucun exemple

Voir aussi

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