forward_list, classe

Décrit un objet qui contrôle une séquence de longueur variable constituée d'éléments. La séquence est stockée en tant que liste de nœuds à liaison unique, chacun contenant un membre de type Type.

Syntaxe

template <class Type,
    class Allocator = allocator<Type>>
class forward_list

Paramètres

Entrez*
Type de données d'élément à stocker dans le forward_list.

Allocator
Objet allocateur stocké qui contient des informations sur l'allocation et la désallocation de mémoire du forward_list. Ce paramètre est facultatif. La valeur par défaut est allocator<Type>.

Notes

Un forward_list objet alloue et libère le stockage pour la séquence qu’il contrôle par le biais d’un objet stocké d’Allocator de classe basé sur la classe d’allocator (communément appelé std::allocator). Pour plus d’informations, consultez Allocateurs. Un objet allocator doit avoir la même interface externe qu’un objet de type allocator.

Remarque

L'objet allocateur stocké n'est pas copié quand l'objet conteneur est assigné.

Les itérateurs, pointeurs et références peuvent devenir non valides quand des éléments de leur séquence contrôlée sont effacés via forward_list. Les insertions et les splices effectuées sur la séquence contrôlée ne forward_list invalident pas les itérateurs.

Des ajouts à la séquence contrôlée peuvent être effectués par des appels à forward_list::insert_after, qui est la seule fonction membre qui appelle le constructeur Type(const T&). forward_list peut également appeler des constructeurs de déplacement. Si une telle expression lève une exception, l'objet conteneur n'insère aucun nouvel élément et relève l'exception. Par conséquent, un objet de type forward_list est laissé dans un état connu lorsque de telles exceptions se produisent.

Membres

Constructeurs

Nom	Description
forward_list	Construit un objet de type forward_list.

Typedefs

Nom	Description
allocator_type	Type qui représente la classe d'allocateur pour un forward_list.
const_iterator	Type qui fournit un itérateur constant pour le forward_list.
const_pointer	Type qui fournit un pointeur vers un élément const dans un forward_list.
const_reference	Type qui fournit une référence constante à un élément dans le forward_list.
difference_type	Type entier signé qui peut être utilisé pour représenter le nombre d'éléments d'un forward_list au sein d'une plage, parmi les éléments vers lesquels pointent les itérateurs.
iterator	Type qui fournit un itérateur pour le forward_list.
pointer	Type qui fournit un pointeur vers un élément du forward_list.
référence	Type qui fournit une référence à un élément du forward_list.
size_type	Type qui représente la distance non signée entre deux éléments.
value_type	Type qui représente le type d'élément stocké dans un forward_list.

Functions

Nom	Description
assign	Efface les éléments d'un forward_list et copie un nouvel ensemble d'éléments dans un forward_list cible.
before_begin	Retourne un itérateur qui traite la position avant le premier élément dans un forward_list.
begin	Retourne un itérateur qui traite le premier élément d'un forward_list.
cbefore_begin	Retourne un itérateur const qui traite la position avant le premier élément dans un forward_list.
cbegin	Retourne un itérateur const qui traite le premier élément d'un forward_list.
cend	Retourne un itérateur const qui traite l'emplacement suivant le dernier élément d'un forward_list.
clear	Efface tous les éléments d'un forward_list.
emplace_after	Construit par déplacement un nouvel élément après la position spécifiée.
emplace_front	Ajoute un élément construit sur place au début de la liste.
empty	Teste si un forward_list est vide.
end	Retourne un itérateur qui traite l'emplacement suivant le dernier élément d'un forward_list.
erase_after	Supprime les éléments du forward_list après une position spécifiée.
front	Retourne une référence au premier élément d'un forward_list.
get_allocator	Retourne une copie de l'objet allocateur utilisé pour construire un forward_list.
insert_after	Ajoute des éléments au forward_list après une position spécifiée.
max_size	Retourne la longueur maximale d'un forward_list.
merge	Supprime les éléments de la liste d'arguments, les insère dans le forward_list cible, puis classe le nouvel ensemble combiné d'éléments dans l'ordre croissant ou dans un autre ordre spécifique.
pop_front	Supprime l'élément au début d'un forward_list.
push_front	Ajoute un élément au début d'un forward_list.
remove	Efface les éléments dans un forward_list qui correspond à une valeur spécifiée.
remove_if	Efface les éléments d’un forward_list pour lequel un prédicat spécifié est satisfait.
resize	Spécifie une nouvelle taille pour un forward_list.
inverser	Inverse l'ordre dans lequel les éléments apparaissent dans un forward_list.
sort	Réorganise les éléments dans l’ordre croissant ou dans un ordre spécifié par un prédicat.
splice_after	Réassocie les liens entre les nœuds.
swap	Échange les éléments de deux forward_list.
unique	Supprime des éléments adjacents qui réussissent un test spécifié.

Opérateurs

Nom	Description
operator=	Remplace les éléments du forward_list par une copie d'un autre forward_list.

allocator_type

Type qui représente la classe d'allocateur pour un forward_list.

typedef Allocator allocator_type;

Notes

allocator_type est un synonyme du paramètre de modèle Allocator.

attribuer

Efface les éléments d'un forward_list et copie un nouvel ensemble d'éléments dans un forward_list cible.

void assign(
    size_type Count,
    const Type& Val);

void assign(
    initializer_list<Type> IList);

template <class InputIterator>
void assign(InputIterator First, InputIterator Last);

Paramètres

first
Début de la plage de remplacement.

last
Fin de la plage de remplacement.

count
Nombre d’éléments à assigner.

val
Valeur à assigner à chaque élément.

Type
Type de la valeur.

IList
Initializer_list à copier.

Notes

Si forward_list est de type entier, la première fonction membre se comporte comme assign((size_type)First, (Type)Last). Sinon, la première fonction membre remplace la séquence contrôlée par *this par la séquence [ First, Last), qui ne doit pas chevaucher la séquence contrôlée initiale.

La deuxième fonction membre remplace la séquence contrôlée par *this par une répétition de Count éléments ayant la valeur Val.

La troisième fonction membre copie les éléments d’initializer_list dans forward_list.

before_begin

Retourne un itérateur qui traite la position avant le premier élément dans un forward_list.

const_iterator before_begin() const;
iterator before_begin();

Valeur de retour

Itérateur vers l’avant qui pointe juste avant le premier élément de la séquence (ou juste avant la fin d’une séquence vide).

Notes

begin

Retourne un itérateur qui traite le premier élément d'un forward_list.

const_iterator begin() const;
iterator begin();

Valeur de retour

Itérateur vers l’avant qui pointe sur le premier élément de la séquence (ou juste après la fin d’une séquence vide).

Notes

cbefore_begin

Retourne un itérateur const qui traite la position avant le premier élément dans un forward_list.

const_iterator cbefore_begin() const;

Valeur de retour

Itérateur vers l’avant qui pointe juste avant le premier élément de la séquence (ou juste avant la fin d’une séquence vide).

Notes

cbegin

Retourne un itérateur const qui traite le premier élément d'une plage.

const_iterator cbegin() const;

Valeur de retour

Itérateur forward const qui pointe vers le premier élément de la plage, ou vers l'emplacement situé juste après la fin d'une plage vide (pour une plage vide : cbegin() == cend()).

Notes

Avec la valeur de retour , les éléments de cbeginla plage ne peuvent pas être modifiés.

Vous pouvez utiliser cette fonction membre à la place de la fonction membre begin() afin de garantir que la valeur de retour est const_iterator. En règle générale, il est utilisé avec le mot clé de déduction de type automatique , comme illustré dans l’exemple suivant. Dans cet exemple, Container est supposé être un conteneur modifiable (autre que const) de type indéfini prenant en charge begin() et cbegin().

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();
// i2 is Container<T>::const_iterator

cend

Retourne un itérateur const qui traite l'emplacement situé immédiatement après le dernier élément d'une plage.

const_iterator cend() const;

Valeur de retour

Itérateur forward qui pointe juste après la fin de la plage.

Notes

cend est utilisé pour vérifier si un itérateur a dépassé la fin de la plage.

Vous pouvez utiliser cette fonction membre à la place de la fonction membre end() afin de garantir que la valeur de retour est const_iterator. En règle générale, il est utilisé avec le mot clé de déduction de type automatique , comme illustré dans l’exemple suivant. Dans cet exemple, Container est supposé être un conteneur modifiable (autre que const) de type indéfini prenant en charge end() et cend().

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

La valeur retournée par cend ne doit pas être déréférencement.

clear

Efface tous les éléments d'un forward_list.

void clear();

Notes

Cette fonction membre appelle erase_after(before_begin(), end()).

const_iterator

Type qui fournit un itérateur constant pour le forward_list.

typedef implementation-defined const_iterator;

Notes

const_iterator décrit un objet pouvant servir d’itérateur vers l’avant constant pour la séquence contrôlée. Il est décrit ici comme synonyme d’un type défini par l’implémentation.

const_pointer

Type qui fournit un pointeur vers un élément const dans un forward_list.

typedef typename Allocator::const_pointer
    const_pointer;

Notes

const_reference

Type qui fournit une référence constante à un élément dans le forward_list.

typedef typename Allocator::const_reference const_reference;

Notes

difference_type

Type entier signé qui peut être utilisé pour représenter le nombre d'éléments d'un forward_list au sein d'une plage, parmi les éléments vers lesquels pointent les itérateurs.

typedef typename Allocator::difference_type difference_type;

Notes

difference_type décrit un objet pouvant représenter la différence entre les adresses de deux éléments de la séquence contrôlée.

emplace_after

Construit par déplacement un nouvel élément après la position spécifiée.

template <class T>
iterator emplace_after(const_iterator Where, Type&& val);

Paramètres

Where
Position dans la liste forward_list cible où le nouvel élément est construit.

val
Argument du constructeur.

Valeur de retour

Itérateur désignant le nouvel élément inséré.

Notes

Cette fonction membre insère un élément avec les arguments de constructeur val juste après l’élément pointé par Where dans la séquence contrôlée. Sinon, son comportement est identique à celui de forward_list::insert_after.

emplace_front

Ajoute un élément construit sur place au début de la liste.

template <class Type>
    void emplace_front(Type&& val);

Paramètres

val
Élément ajouté au début de la liste forward_list.

Notes

Cette fonction membre insère un élément avec les arguments de constructeur _ val à la fin de la séquence contrôlée.

Si une exception est levée, le conteneur n’est pas modifié et l’exception est levée de nouveau.

empty

Teste si un forward_list est vide.

bool empty() const;

Valeur de retour

true si la liste forward_list est vide ; sinon, false.

end

Retourne un itérateur qui traite l'emplacement suivant le dernier élément d'un forward_list.

const_iterator end() const;
iterator end();

Valeur de retour

Retourne un itérateur vers l’avant qui pointe juste après la fin de la séquence.

erase_after

Supprime les éléments du forward_list après une position spécifiée.

iterator erase_after(const_iterator Where);
iterator erase_after(const_iterator first, const_iterator last);

Paramètres

Where
Position dans la liste forward_list cible où le nouvel élément est effacé.

first
Début de la plage à effacer.

last
Fin de la plage à effacer.

Valeur de retour

Itérateur qui désigne le premier élément restant après tous les éléments supprimés, ou forward_list::end si aucun élément de ce genre n’existe.

Notes

La première fonction membre supprime l’élément de la séquence contrôlée juste après Where.

La deuxième fonction membre supprime l’élément de la séquence contrôlée dans la plage ( first, last) (aucun point de fin n’est inclus).

L’effacement de N éléments entraîne N appels de destructeur. Une réallocation se produit, et les itérateurs et les références deviennent non valides pour les éléments effacés.

Les fonctions membres ne lèvent jamais d'exception.

forward_list

Construit un objet de type forward_list.

forward_list();
explicit forward_list(const Allocator& Al);
explicit forward_list(size_type Count);
forward_list(size_type Count, const Type& Val);
forward_list(size_type Count, const Type& Val, const Allocator& Al);
forward_list(const forward_list& Right);
forward_list(const forward_list& Right, const Allocator& Al);
forward_list(forward_list&& Right);
forward_list(forward_list&& Right, const Allocator& Al);
forward_list(initializer_list<Type> IList, const Alloc& Al);
template <class InputIterator>
forward_list(InputIterator First, InputIterator Last);
template <class InputIterator>
forward_list(InputIterator First, InputIterator Last, const Allocator& Al);

Paramètres

Al
Classe allocator à utiliser avec cet objet.

Count
Nombre d'éléments dans la liste construite.

Val
Valeur des éléments contenus dans la liste construite.

Right
Liste dont la liste construite doit être une copie.

First
Position du premier élément de la plage d'éléments à copier.

Dernière
Position du premier élément au-delà de la plage d'éléments à copier.

IList
Initializer_list à copier.

Notes

Tous les constructeurs stockent un allocator et initialisent la séquence contrôlée. L’objet allocator est l’argument Al, le cas échéant. Pour le constructeur de copie, c’est right.get_allocator(). Dans le cas contraire, il prend la valeur Allocator().

Les deux premiers constructeurs spécifient une séquence contrôlée initiale vide.

Le troisième constructeur spécifie une répétition des éléments Count de valeur Type().

Les quatrième et cinquième constructeurs spécifient une répétition des éléments Count de valeur Val.

Le sixième constructeur spécifie une copie de la séquence contrôlée par Right. Si InputIterator est un type entier, les deux constructeurs suivants spécifient une répétition des (size_type)First éléments ayant la valeur (Type)Last. Sinon, les deux constructeurs suivants spécifient la séquence [First, Last).

Les neuvième et dixième constructeurs sont les mêmes que le sixième, mais avec une référence rvalue.

Le dernier constructeur spécifie la séquence contrôlée initiale avec un objet de classe initializer_list<Type>.

front

Retourne une référence au premier élément d'un forward_list.

reference front();
const_reference front() const;

Valeur de retour

Référence au premier élément de la séquence contrôlée, qui ne doit pas être vide.

get_allocator

Retourne une copie de l'objet allocateur utilisé pour construire un forward_list.

allocator_type get_allocator() const;

Valeur de retour

Objet allocateur stocké.

insert_after

Ajoute des éléments au forward_list après une position spécifiée.

iterator insert_after(const_iterator Where, const Type& Val);
void insert_after(const_iterator Where, size_type Count, const Type& Val);
void insert_after(const iterator Where, initializer_list<Type> IList);
iterator insert_after(const_iterator Where, Type&& Val);
template <class InputIterator>
    void insert_after(const_iterator Where, InputIterator First, InputIterator Last);

Paramètres

Where
Position dans la liste forward_list cible où le premier élément est inséré.

Count
Nombre d’éléments à insérer.

First
Début de la plage d’insertion.

Dernière
Fin de la plage d’insertion.

Val
Élément ajouté à la liste forward_list.

IList
Initializer_list à insérer.

Valeur de retour

Itérateur qui désigne le nouvel élément inséré (première et deuxième fonctions membres uniquement).

Notes

Chacune des fonctions membres insère, juste après l’élément pointé par Where dans la séquence contrôlée, une séquence spécifiée par les opérandes restants.

La première fonction membre insère un élément qui a la valeur Val et retourne un itérateur qui désigne l’élément nouvellement inséré.

La deuxième fonction membre insère une répétition des éléments Count de valeur Val.

Si InputIterator est un type entier, la troisième fonction membre se comporte comme insert(it, (size_type)First, (Type)Last). Sinon, elle insère la séquence [First, Last), qui ne doit pas chevaucher la séquence contrôlée initiale.

La quatrième fonction membre insère la séquence spécifiée par un objet de classe initializer_list<Type>.

La dernière fonction membre est la même que la première, mais avec une référence rvalue.

L’insertion de N éléments entraîne N appels de constructeur. Une réallocation se produit, mais aucun itérateur ou référence ne devient non valide.

Si une exception est levée pendant l’insertion d’un ou plusieurs éléments, le conteneur n’est pas modifié et l’exception est levée de nouveau.

iterator

Type qui fournit un itérateur pour le forward_list.

typedef implementation-defined iterator;

Notes

iterator décrit un objet pouvant servir d’itérateur vers l’avant pour la séquence contrôlée. Il est décrit ici comme synonyme d’un type défini par l’implémentation.

max_size

Retourne la longueur maximale d'un forward_list.

size_type max_size() const;

Valeur de retour

Longueur de la séquence la plus longue que l’objet peut contrôler.

Notes

merge

Combine les deux séquences triées en une seule séquence triée en temps linéaire. Supprime les éléments de la liste d’arguments et les insère dans ce forward_list. Les deux listes doivent être triées par le même objet de fonction de comparaison avant l’appel à merge. La liste combinée est triée par l’objet de fonction de comparaison.

void merge(forward_list& right);
template <class Predicate>
    void merge(forward_list& right, Predicate comp);

Paramètres

right
Liste forward_list à partir de laquelle effectuer la fusion.

comp
Objet de fonction de comparaison utilisé pour trier les éléments.

Notes

forward_list::merge supprime les éléments du forward_list right, et les insère dans ce forward_list. Les deux séquences doivent être triées par le même prédicat, décrit ci-dessous. La séquence combinée est également ordonnée par cet objet de fonction de comparaison.

Pour les itérateurs Pi et Pj désignant des éléments aux positions i et j, la première fonction membre impose l’ordre !(*Pj < *Pi) chaque fois que i < j. (Les éléments sont triés dans l’ordre ascending .) La deuxième fonction membre impose l’ordre ! comp(*Pj, *Pi) à chaque fois i < jque .

Aucune paire d’éléments dans la séquence contrôlée d’origine n’est inversée dans la séquence contrôlée obtenue. Si deux éléments de la séquence contrôlée obtenue sont égaux ( !(*Pi < *Pj) && !(*Pj < *Pi)), un élément de la séquence contrôlée d’origine apparaît avant un élément de la séquence contrôlée par right.

Une exception se produit uniquement si comp lève une exception. Dans ce cas, la séquence contrôlée conserve un ordre non spécifié et l’exception est levée de nouveau.

opérateur =

Remplace les éléments du forward_list par une copie d'un autre forward_list.

forward_list& operator=(const forward_list& right);
forward_list& operator=(initializer_list<Type> IList);
forward_list& operator=(forward_list&& right);

Paramètres

right
Liste forward_list copiée dans la liste forward_list.

IList
Liste d’initialiseurs entre accolades, qui se comporte comme une séquence d’éléments de type Type.

Notes

Le premier opérateur membre remplace la séquence contrôlée par une copie de la séquence contrôlée par le droit.

Le deuxième opérateur membre remplace la séquence contrôlée à partir d’un objet de classe initializer_list<Type>.

Le troisième opérateur membre est le même que le premier, mais avec une référence rvalue.

pointer

Type qui fournit un pointeur vers un élément du forward_list.

typedef typename Allocator::pointer pointer;

pop_front

Supprime l'élément au début d'un forward_list.

void pop_front();

Notes

Le premier élément de la liste forward_list ne doit pas être vide.

La fonction membre ne lève jamais d’exception.

push_front

Ajoute un élément au début d'un forward_list.

void push_front(const Type& val);
void push_front(Type&& val);

Paramètres

val
Élément ajouté au début de la liste forward_list.

Notes

Si une exception est levée, le conteneur n’est pas modifié et l’exception est levée de nouveau.

référence

Type qui fournit une référence à un élément du forward_list.

typedef typename Allocator::reference reference;

remove

Efface les éléments dans un forward_list qui correspond à une valeur spécifiée.

void remove(const Type& val);

Paramètres

val
Valeur qui, si elle est contenue dans un élément, entraîne la suppression de cet élément de la liste.

Notes

La fonction membre supprime de la séquence contrôlée tous les éléments désignés par l’itérateur P pour lesquels *P == val.

La fonction membre ne lève jamais d’exception.

remove_if

Efface les éléments d’un forward_list pour lequel un prédicat spécifié est satisfait.

template <class Predicate>
    void remove_if(Predicate pred);

Paramètres

Pred
Prédicat unaire qui, s’il est satisfait par un élément, entraîne la suppression de cet élément de la liste.

Notes

La fonction membre supprime de la séquence contrôlée tous les éléments désignés par l’itérateur P pour lesquels pred(*P) est true.

Une exception se produit uniquement si elle lève une exception. Dans ce cas, la séquence contrôlée conserve un état non spécifié et l’exception est levée de nouveau.

resize

Spécifie une nouvelle taille pour un forward_list.

void resize(size_type _Newsize);
void resize(size_type _Newsize, const Type& val);

Paramètres

_Newsize
Nombre d’éléments dans la liste forward_list redimensionnée.

val
Valeur à utiliser pour le remplissage.

Notes

Les fonctions membres garantissent tous deux que le nombre d’éléments de la liste est désormais _Newsize. Si elle doit rendre la séquence contrôlée plus longue, la première fonction membre ajoute des éléments avec valeur Type(), tandis que la deuxième fonction membre ajoute des éléments avec valeur val. Pour raccourcir la séquence contrôlée, les deux fonctions membres appellent erase_after(begin() + _Newsize - 1, end()).

inverser

Inverse l'ordre dans lequel les éléments apparaissent dans un forward_list.

void reverse();

size_type

Type qui représente la distance non signée entre deux éléments.

typedef typename Allocator::size_type size_type;

Notes

Le type d'entier non signé décrit un objet qui peut représenter la longueur de n'importe quelle séquence contrôlée.

sort

Réorganise les éléments dans l’ordre croissant ou dans un ordre spécifié par un prédicat.

void sort();
template <class Predicate>
void sort(Predicate pred);

Paramètres

Pred
Prédicat de tri.

Notes

Les deux fonctions membres ordonnent les éléments dans la séquence contrôlée selon un prédicat, décrit ci-dessous.

Pour les itérateurs Pi et Pj désignant des éléments aux positions i et j, la première fonction membre impose l’ordre !(*Pj < *Pi) chaque fois que i < j. (Les éléments sont triés dans l’ordre ascending .) La fonction de modèle membre impose l’ordre ! pred(*Pj, *Pi) à chaque fois i < jque . Aucune paire d’éléments ordonnée dans la séquence contrôlée d’origine n’est inversée dans la séquence contrôlée obtenue. (Le tri est stable.)

Une exception se produit uniquement si elle lève une exception. Dans ce cas, la séquence contrôlée conserve un ordre non spécifié et l’exception est levée de nouveau.

splice_after

Supprime des éléments d'une liste forward_list source et les insère dans une liste forward_list de destination.

// insert the entire source forward_list
void splice_after(const_iterator Where, forward_list& Source);
void splice_after(const_iterator Where, forward_list&& Source);

// insert one element of the source forward_list
void splice_after(const_iterator Where, forward_list& Source, const_iterator Iter);
void splice_after(const_iterator Where, forward_list&& Source, const_iterator Iter);

// insert a range of elements from the source forward_list
void splice_after(
    const_iterator Where,
    forward_list& Source,
    const_iterator First,
    const_iterator Last);

void splice_after(
    const_iterator Where,
    forward_list&& Source,
    const_iterator First,
    const_iterator Last);

Paramètres

Where
Position dans la liste forward_list de destination après laquelle l'insertion doit être effectuée.

Source
Liste forward_list source qui doit être insérée dans la liste forward_list de destination.

Iter
Élément à insérer à partir de la liste forward_list source.

First
Premier élément de la plage à insérer à partir de la liste forward_list source.

Dernière
Première position au-delà de la plage à insérer à partir de la liste forward_list source.

Notes

La première paire de fonctions membres insère la séquence contrôlée par source juste après l’élément de la séquence contrôlée pointée par Where. Elle supprime également tous les éléments de la source. ( &Source ne doit pas être égal à this.)

La deuxième paire de fonctions membres supprime l’élément juste après Iter dans la séquence contrôlée par source et l’insère juste après l’élément de la séquence contrôlée pointée par Where. (Si Where == Iter || Where == ++Iter, aucune modification ne se produit.)

La troisième paire de fonctions membres (splice ranged) insère la sous-plage désignée par (First, Last) la séquence contrôlée par source juste après l’élément de la séquence contrôlée pointée vers Where. Elle supprime également la sous-plage d’origine de la séquence contrôlée par source. (Si &Source == this, la plage (First, Last) ne doit pas inclure l’élément pointé par Where.)

Si la méthode splice à plage insère N éléments et que &Source != this, un objet de classe iterator est incrémenté N fois.

Aucun itérateur, pointeur ou référence qui désigne des éléments ajoutés n'est invalidé.

Exemple

// forward_list_splice_after.cpp
// compile with: /EHsc /W4
#include <forward_list>
#include <iostream>

using namespace std;

template <typename S> void print(const S& s) {
    for (const auto& p : s) {
        cout << "(" << p << ") ";
    }

    cout << endl;
}

int main()
{
    forward_list<int> c1{ 10, 11 };
    forward_list<int> c2{ 20, 21, 22 };
    forward_list<int> c3{ 30, 31 };
    forward_list<int> c4{ 40, 41, 42, 43 };

    forward_list<int>::iterator where_iter;
    forward_list<int>::iterator first_iter;
    forward_list<int>::iterator last_iter;

    cout << "Beginning state of lists:" << endl;
    cout << "c1 = ";
    print(c1);
    cout << "c2 = ";
    print(c2);
    cout << "c3 = ";
    print(c3);
    cout << "c4 = ";
    print(c4);

    where_iter = c2.begin();
    ++where_iter; // start at second element
    c2.splice_after(where_iter, c1);
    cout << "After splicing c1 into c2:" << endl;
    cout << "c1 = ";
    print(c1);
    cout << "c2 = ";
    print(c2);

    first_iter = c3.begin();
    c2.splice_after(where_iter, c3, first_iter);
    cout << "After splicing the first element of c3 into c2:" << endl;
    cout << "c3 = ";
    print(c3);
    cout << "c2 = ";
    print(c2);

    first_iter = c4.begin();
    last_iter = c4.end();
    // set up to get the middle elements
    ++first_iter;
    c2.splice_after(where_iter, c4, first_iter, last_iter);
    cout << "After splicing a range of c4 into c2:" << endl;
    cout << "c4 = ";
    print(c4);
    cout << "c2 = ";
    print(c2);
}

Beginning state of lists:c1 = (10) (11)c2 = (20) (21) (22)c3 = (30) (31)c4 = (40) (41) (42) (43)After splicing c1 into c2:c1 =c2 = (20) (21) (10) (11) (22)After splicing the first element of c3 into c2:c3 = (30)c2 = (20) (21) (31) (10) (11) (22)After splicing a range of c4 into c2:c4 = (40) (41)c2 = (20) (21) (42) (43) (31) (10) (11) (22)

swap

Échange les éléments de deux forward_list.

void swap(forward_list& right);

Paramètres

right
Liste forward_list qui fournit les éléments à échanger.

Notes

La fonction membre échange les séquences contrôlées entre *this et droite. Si get_allocator() == right.get_allocator(), elle le fait en temps constant, ne lève aucune exception et n’invalide aucune référence, pointeur ou itérateur qui désigne des éléments dans les deux séquences contrôlées. Sinon, il effectue des affectations d’éléments et des appels de constructeur proportionnels au nombre d’éléments dans les deux séquences contrôlées.

unique

Élimine tous les éléments sauf le premier de chaque groupe consécutif d’éléments égaux.

void unique();
template <class BinaryPredicate>
void unique(BinaryPredicate comp);

Paramètres

comp
Prédicat binaire utilisé pour comparer des éléments consécutifs.

Notes

Conserve le premier de chaque élément unique et supprime le reste. Les éléments doivent être triés pour que les éléments de valeur égale soient adjacents dans la liste.

La première fonction membre supprime de la séquence contrôlée chaque élément dont la valeur est égale à celle de l’élément précédent. Pour les itérateurs Pi et Pj désignant des éléments aux positions i et j, la deuxième fonction membre supprime chaque élément pour lequel i + 1 == j && comp(*Pi, *Pj).

Pour une séquence contrôlée de longueur N (> 0), le prédicat comp(*Pi, *Pj) est évalué N - 1 à des heures.

Une exception se produit uniquement si comp lève une exception. Dans ce cas, la séquence contrôlée conserve un état non spécifié et l’exception est levée de nouveau.

value_type

Type qui représente le type d'élément stocké dans un forward_list.

typedef typename Allocator::value_type value_type;

Notes

Le type est un synonyme du paramètre de modèle Type.