list (STL/CLR)

Article
10/12/2023

La classe de modèle décrit un objet qui contrôle une séquence d’éléments de longueur variable ayant un accès bidirectionnel. Vous utilisez le conteneur list pour gérer une séquence d’éléments en tant que liste de nœuds bidirectionnelle liée, chacune stockant un élément.

Dans la description ci-dessous, GValue est identique à Value , sauf si ce dernier est un type ref, auquel cas il s’agit Value^.

Syntaxe

template<typename Value>
    ref class list
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        Microsoft::VisualC::StlClr::IList<GValue>
    { ..... };

Paramètres

Valeur
Type d'un élément dans la séquence contrôlée.

Spécifications

Header :<cliext/list>

Namespace : cliext

Déclarations

Définition de type	Description
list::const_iterator (STL/CLR)	Type d'un itérateur constant pour la séquence contrôlée.
list::const_reference (STL/CLR)	Type d'une référence constante à un élément.
list::const_reverse_iterator (STL/CLR)	Type d'un itérateur inserve constant pour la séquence contrôlée.
list::difference_type (STL/CLR)	Type d'une distance signée entre deux éléments.
list::generic_container (STL/CLR)	Type de l’interface générique pour le conteneur.
list::generic_iterator (STL/CLR)	Type d’itérateur pour l’interface générique du conteneur.
list::generic_reverse_iterator (STL/CLR)	Type d’itérateur inverse pour l’interface générique du conteneur.
list::generic_value (STL/CLR)	Type d’un élément pour l’interface générique du conteneur.
list::iterator (STL/CLR)	Type d'un itérateur pour la séquence contrôlée.
list::reference (STL/CLR)	Type d'une référence à un élément.
list::reverse_iterator (STL/CLR)	Type d'un itérateur inverse pour la séquence contrôlée.
list::size_type (STL/CLR)	Type d'une distance signée entre deux éléments.
list::value_type (STL/CLR)	Type d’un élément.

Fonction membre	Description
list::assign (STL/CLR)	Remplace tous les éléments.
list::back (STL/CLR)	Accède au dernier élément.
list::begin (STL/CLR)	Désigne le début de la séquence contrôlée.
list::clear (STL/CLR)	Supprime tous les éléments.
list::empty (STL/CLR)	Vérifie l'absence d'éléments.
list::end (STL/CLR)	Désigne la fin de la séquence contrôlée.
list::erase (STL/CLR)	Supprime les éléments placés aux positions spécifiées.
list::front (STL/CLR)	Accède au premier élément.
list::insert (STL/CLR)	Ajoute des éléments à une position spécifiée.
list::list (STL/CLR)	Construit un objet conteneur.
list::merge (STL/CLR)	Fusionne deux séquences contrôlées ordonnées.
list::pop_back (STL/CLR)	Supprime le dernier élément.
list::pop_front (STL/CLR)	Supprime le premier élément.
list::push_back (STL/CLR)	Ajoute un nouvel élément.
list::push_front (STL/CLR)	Ajoute un nouvel élément.
list::rbegin (STL/CLR)	Désigne le début de la séquence contrôlée inverse.
list::remove (STL/CLR)	Supprime un élément avec une valeur spécifiée.
list::remove_if (STL/CLR)	Supprime les éléments qui passent un test spécifié.
list::rend (STL/CLR)	Désigne la fin de la séquence contrôlée inverse.
list::resize (STL/CLR)	Modifie le nombre d’éléments.
list::reverse (STL/CLR)	Inverse la séquence contrôlée.
list::size (STL/CLR)	Compte le nombre d'éléments.
list::sort (STL/CLR)	Commande la séquence contrôlée.
list::splice (STL/CLR)	Réassocie les liens entre les nœuds.
list::swap (STL/CLR)	Échange le contenu de deux conteneurs.
list::to_array (STL/CLR)	Copie la séquence contrôlée dans un nouveau tableau.
list::unique (STL/CLR)	Supprime des éléments adjacents qui réussissent un test spécifié.

Propriété	Description
list::back_item (STL/CLR)	Accède au dernier élément.
list::front_item (STL/CLR)	Accède au premier élément.

Opérateur	Description
list::operator= (STL/CLR)	Remplace la séquence contrôlée.
operator!= (list) (STL/CLR)	Détermine si un `list` objet n’est pas égal à un autre `list` objet.
opérateur< (list) (STL/CLR)	Détermine si un `list` objet est inférieur à un autre `list` objet.
operator<= (list) (STL/CLR)	Détermine si un `list` objet est inférieur ou égal à un autre `list` objet.
operator== (list) (STL/CLR)	Détermine si un `list` objet est égal à un autre `list` objet.
opérateur> (list) (STL/CLR)	Détermine si un `list` objet est supérieur à un autre `list` objet.
operator>= (list) (STL/CLR)	Détermine si un `list` objet est supérieur ou égal à un autre `list` objet.

Interfaces

Interface	Description
ICloneable	Dupliquer un objet.
IEnumerable	Séquencer des éléments.
ICollection	Conservez le groupe d’éléments.
IEnumerable<T>	Séquence à l’aide d’éléments typés.
ICollection<T>	Conservez le groupe d’éléments typés.
Valeur IList<>	Gérer le conteneur générique.

Notes

L’objet alloue et libère le stockage pour la séquence qu’il contrôle en tant que nœuds individuels dans une liste de liens bidirectionnelles. Il réorganise les éléments en modifiant les liens entre les nœuds, jamais en copiant le contenu d’un nœud vers un autre. Cela signifie que vous pouvez insérer et supprimer librement des éléments sans déranger les éléments restants. Ainsi, une liste est un bon candidat pour le conteneur sous-jacent pour la file d’attente de classes de modèle (STL/CLR) ou la pile de classes de modèle (STL/CLR).

Un list objet prend en charge les itérateurs bidirectionnels, ce qui signifie que vous pouvez effectuer une étape vers des éléments adjacents en fonction d’un itérateur qui désigne un élément dans la séquence contrôlée. Un nœud principal spécial correspond à l’itérateur retourné par list ::end (STL/CLR)(). Vous pouvez décrémenter cet itérateur pour atteindre le dernier élément de la séquence contrôlée, le cas échéant. Vous pouvez incrémenter un itérateur de liste pour atteindre le nœud principal, puis le comparer égal à end(). Mais vous ne pouvez pas déréférencer l’itérateur retourné par end().

Notez que vous ne pouvez pas faire référence à un élément de liste directement en fonction de sa position numérique, ce qui nécessite un itérateur d’accès aléatoire. Par conséquent, une liste n’est pas utilisable comme conteneur sous-jacent pour la classe de modèle priority_queue (STL/CLR).

Un itérateur de liste stocke un handle sur son nœud de liste associé, qui stocke à son tour un handle dans son conteneur associé. Vous pouvez utiliser des itérateurs uniquement avec leurs objets conteneur associés. Un itérateur de liste reste valide tant que son nœud de liste associé est associé à une liste. En outre, un itérateur valide est déreferencable - vous pouvez l’utiliser pour accéder ou modifier la valeur de l’élément qu’il désigne -- tant qu’il n’est pas égal à end().

L’effacement ou la suppression d’un élément appelle le destructeur pour sa valeur stockée. La destruction du conteneur efface tous les éléments. Ainsi, un conteneur dont le type d’élément est une classe ref garantit qu’aucun élément n’est hors service du conteneur. Notez toutefois qu’un conteneur de handles ne détruit pas ses éléments.

Membres

list::assign (STL/CLR)

Remplace tous les éléments.

Syntaxe

void assign(size_type count, value_type val);
template<typename InIt>
    void assign(InIt first, InIt last);
void assign(System::Collections::Generic::IEnumerable<Value>^ right);

Paramètres

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

first
Début de la plage à insérer.

last
Fin de la plage à insérer.

right
Énumération à insérer.

val
Valeur de l’élément à insérer.

Notes

La première fonction membre remplace la séquence contrôlée par une répétition de nombre d’éléments de valeur val. Vous l’utilisez pour remplir le conteneur avec des éléments ayant toutes la même valeur.

S’il InIt s’agit d’un type entier, la deuxième fonction membre se comporte de la même façon que assign((size_type)first, (value_type)last). Sinon, il remplace la séquence contrôlée par la séquence [first, last). Vous l’utilisez pour rendre la séquence contrôlée une copie d’une autre séquence.

La troisième fonction membre remplace la séquence contrôlée par la séquence désignée par le droit de l’énumérateur. Vous l’utilisez pour rendre la séquence contrôlée une copie d’une séquence décrite par un énumérateur.

Exemple

// cliext_list_assign.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // assign a repetition of values
    cliext::list<wchar_t> c2;
    c2.assign(6, L'x');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign an iterator range
    cliext::list<wchar_t>::iterator it = c1.end();
    c2.assign(c1.begin(), --it);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign an enumeration
    c2.assign(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

x x x x x x
a b
a b c

list::back (STL/CLR)

Accède au dernier élément.

Syntaxe

reference back();

Notes

La fonction membre retourne une référence au dernier élément de la séquence contrôlée, qui doit être non vide. Vous l’utilisez pour accéder au dernier élément, lorsque vous savez qu’il existe.

Exemple

// cliext_list_back.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect last item
    System::Console::WriteLine("back() = {0}", c1.back());

    // alter last item and reinspect
    c1.back() = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
back() = c
a b x

list::back_item (STL/CLR)

Accède au dernier élément.

Syntaxe

property value_type back_item;

Notes

La propriété accède au dernier élément de la séquence contrôlée, qui doit être non vide. Vous l’utilisez pour lire ou écrire le dernier élément, lorsque vous savez qu’il existe.

Exemple

// cliext_list_back_item.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect last item
    System::Console::WriteLine("back_item = {0}", c1.back_item);

    // alter last item and reinspect
    c1.back_item = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
back_item = c
a b x

list::begin (STL/CLR)

Désigne le début de la séquence contrôlée.

Syntaxe

iterator begin();

Notes

La fonction membre retourne un itérateur d’accès aléatoire qui désigne le premier élément de la séquence contrôlée, ou juste au-delà de la fin d’une séquence vide. Vous l’utilisez pour obtenir un itérateur qui désigne le current début de la séquence contrôlée, mais son état peut changer si la longueur de la séquence contrôlée change.

Exemple

// cliext_list_begin.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items
    cliext::list<wchar_t>::iterator it = c1.begin();
    System::Console::WriteLine("*begin() = {0}", *it);
    System::Console::WriteLine("*++begin() = {0}", *++it);

    // alter first two items and reinspect
    *--it = L'x';
    *++it = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*begin() = a
*++begin() = b
x y c

list::clear (STL/CLR)

Supprime tous les éléments.

Syntaxe

void clear();

Notes

La fonction membre appelle efficacement list ::erase (STL/CLR)( list ::begin (STL/CLR)(), list ::end (STL/CLR)()). Vous l’utilisez pour vous assurer que la séquence contrôlée est vide.

Exemple

// cliext_list_clear.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());

    // add elements and clear again
    c1.push_back(L'a');
    c1.push_back(L'b');

    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
size() = 0
a b
size() = 0

list::const_iterator (STL/CLR)

Type d'un itérateur constant pour la séquence contrôlée.

Syntaxe

typedef T2 const_iterator;

Notes

Le type décrit un objet de type T2 non spécifié qui peut servir d’itérateur d’accès aléatoire constant pour la séquence contrôlée.

Exemple

// cliext_list_const_iterator.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    cliext::list<wchar_t>::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        System::Console::Write("{0} ", *cit);
    System::Console::WriteLine();
    return (0);
    }

a b c

list::const_reference (STL/CLR)

Type d'une référence constante à un élément.

Syntaxe

typedef value_type% const_reference;

Notes

Le type décrit une référence constante à un élément.

Exemple

// cliext_list_const_reference.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    cliext::list<wchar_t>::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        cliext::list<wchar_t>::const_reference cref = *cit;
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

list::const_reverse_iterator (STL/CLR)

Type d’itérateur inverse constant pour la séquence contrôlée.

Syntaxe

typedef T4 const_reverse_iterator;

Notes

Le type décrit un objet de type T4 non spécifié qui peut servir d’itérateur inverse constant pour la séquence contrôlée.

Exemple

// cliext_list_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" reversed
    cliext::list<wchar_t>::const_reverse_iterator crit = c1.rbegin();
    cliext::list<wchar_t>::const_reverse_iterator crend = c1.rend();
    for (; crit != crend; ++crit)
        System::Console::Write("{0} ", *crit);
    System::Console::WriteLine();
    return (0);
    }

c b a

list::difference_type (STL/CLR)

Types d’une distance signée entre deux éléments.

Syntaxe

typedef int difference_type;

Notes

Le type décrit un nombre d’éléments signés.

Exemple

// cliext_list_difference_type.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // compute positive difference
    cliext::list<wchar_t>::difference_type diff = 0;
    for (cliext::list<wchar_t>::iterator it = c1.begin();
        it != c1.end(); ++it) ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);

    // compute negative difference
    diff = 0;
    for (cliext::list<wchar_t>::iterator it = c1.end();
        it != c1.begin(); --it) --diff;
    System::Console::WriteLine("begin()-end() = {0}", diff);
    return (0);
    }

a b c
end()-begin() = 3
begin()-end() = -3

list::empty (STL/CLR)

Vérifie l'absence d'éléments.

Syntaxe

bool empty();

Notes

La fonction membre retourne la valeur true pour une séquence contrôlée vide. Il équivaut à list ::size (STL/CLR)() == 0. Vous l’utilisez pour tester si la liste est vide.

Exemple

// cliext_list_empty.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0}", c1.size());
    System::Console::WriteLine("empty() = {0}", c1.empty());
    return (0);
    }

a b c
size() = 3
empty() = False
size() = 0
empty() = True

list::end (STL/CLR)

Désigne la fin de la séquence contrôlée.

Syntaxe

iterator end();

Notes

La fonction membre retourne un itérateur d’accès aléatoire qui pointe juste au-delà de la fin de la séquence contrôlée. Vous l’utilisez pour obtenir un itérateur qui désigne la fin de la séquence contrôlée ; son état ne change pas si la longueur de la séquence contrôlée change.

Exemple

// cliext_list_end.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect last two items
    cliext::list<wchar_t>::iterator it = c1.end();
    --it;
    System::Console::WriteLine("*-- --end() = {0}", *--it);
    System::Console::WriteLine("*--end() = {0}", *++it);

    // alter first two items and reinspect
    *--it = L'x';
    *++it = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*-- --end() = b
*--end() = c
a x y

list::erase (STL/CLR)

Supprime les éléments placés aux positions spécifiées.

Syntaxe

iterator erase(iterator where);
iterator erase(iterator first, iterator last);

Paramètres

first
Début de la plage à effacer.

last
Fin de la plage à effacer.

where
Élément à effacer.

Notes

La première fonction membre supprime l’élément de la séquence contrôlée vers laquelle. Vous l’utilisez pour supprimer un seul élément.

La deuxième fonction membre supprime l’élément de la séquence contrôlée dans la plage [first, last). Vous l’utilisez pour supprimer zéro ou plusieurs éléments contigus.

Les deux fonctions membres retournent un itérateur qui désigne le premier élément restant au-delà des éléments supprimés, ou list ::end (STL/CLR)() si aucun élément de ce type n’existe.

Lors de l’effacement des éléments, le nombre de copies d’éléments est linéaire dans le nombre d’éléments entre la fin de l’effacement et la fin la plus proche de la séquence. (Lors de l’effacement d’un ou plusieurs éléments à la fin de la séquence, aucun élément ne se produit.)

Exemple

// cliext_list_erase.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // erase an element and reinspect
    System::Console::WriteLine("erase(begin()) = {0}",
        *c1.erase(c1.begin()));

    // add elements and display " b c d e"
    c1.push_back(L'd');
    c1.push_back(L'e');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // erase all but end
    cliext::list<wchar_t>::iterator it = c1.end();
    System::Console::WriteLine("erase(begin(), end()-1) = {0}",
        *c1.erase(c1.begin(), --it));
    System::Console::WriteLine("size() = {0}", c1.size());
    return (0);
    }

a b c
erase(begin()) = b
b c d e
erase(begin(), end()-1) = e
size() = 1

list::front (STL/CLR)

Accède au premier élément.

Syntaxe

reference front();

Notes

La fonction membre retourne une référence au premier élément de la séquence contrôlée, qui doit être non vide. Vous l’utilisez pour lire ou écrire le premier élément, lorsque vous savez qu’il existe.

Exemple

// cliext_list_front.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first item
    System::Console::WriteLine("front() = {0}", c1.front());

    // alter first item and reinspect
    c1.front() = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
front() = a
x b c

list::front_item (STL/CLR)

Accède au premier élément.

Syntaxe

property value_type front_item;

Notes

La propriété accède au premier élément de la séquence contrôlée, qui doit être non vide. Vous l’utilisez pour lire ou écrire le premier élément, lorsque vous savez qu’il existe.

Exemple

// cliext_list_front_item.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first item
    System::Console::WriteLine("front_item = {0}", c1.front_item);

    // alter first item and reinspect
    c1.front_item = L'x';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
front_item = a
x b c

list::generic_container (STL/CLR)

Type de l’interface générique pour le conteneur.

Syntaxe

typedef Microsoft::VisualC::StlClr::
    IList<generic_value>
    generic_container;

Notes

Le type décrit l’interface générique pour cette classe de conteneur de modèle.

Exemple

// cliext_list_generic_container.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    cliext::list<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    gc1->insert(gc1->end(), L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify original and display generic
    c1.push_back(L'e');

    System::Collections::IEnumerator^ enum1 =
        gc1->GetEnumerator();
    while (enum1->MoveNext())
        System::Console::Write("{0} ", enum1->Current);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a b c d
a b c d e

list::generic_iterator (STL/CLR)

Type d’itérateur à utiliser avec l’interface générique du conteneur.

Syntaxe

typedef Microsoft::VisualC::StlClr::Generic::
    ContainerBidirectionalIterator<generic_value>
    generic_iterator;

Notes

Le type décrit un itérateur générique qui peut être utilisé avec l’interface générique pour cette classe de conteneur de modèle.

Exemple

// cliext_list_generic_iterator.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    cliext::list<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    cliext::list<wchar_t>::generic_iterator gcit = gc1->begin();
    cliext::list<wchar_t>::generic_value gcval = *gcit;
    *++gcit = gcval;
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a a c

list::generic_reverse_iterator (STL/CLR)

Type d’itérateur inverse à utiliser avec l’interface générique du conteneur.

Syntaxe

typedef Microsoft::VisualC::StlClr::Generic::
    ReverseBidirectionalIterator<generic_value> generic_reverse_iterator;

Notes

Le type décrit un itérateur inverse générique qui peut être utilisé avec l’interface générique pour cette classe de conteneur de modèle.

Exemple

// cliext_list_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    cliext::list<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    cliext::list<wchar_t>::generic_reverse_iterator gcit = gc1->rbegin();
    cliext::list<wchar_t>::generic_value gcval = *gcit;
    *++gcit = gcval;
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a c c

list::generic_value (STL/CLR)

Type d’un élément à utiliser avec l’interface générique du conteneur.

Syntaxe

typedef GValue generic_value;

Notes

Le type décrit un objet de type GValue qui décrit la valeur de l’élément stocké à utiliser avec l’interface générique pour cette classe de conteneur de modèle.

Exemple

// cliext_list_generic_value.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct a generic container
    cliext::list<wchar_t>::generic_container^ gc1 = %c1;
    for each (wchar_t elem in gc1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // modify generic and display original
    cliext::list<wchar_t>::generic_iterator gcit = gc1->begin();
    cliext::list<wchar_t>::generic_value gcval = *gcit;
    *++gcit = gcval;
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a a c

list::insert (STL/CLR)

Ajoute des éléments à une position spécifiée.

Syntaxe

iterator insert(iterator where, value_type val);
void insert(iterator where, size_type count, value_type val);
template<typename InIt>
    void insert(iterator where, InIt first, InIt last);
void insert(iterator where,
    System::Collections::Generic::IEnumerable<Value>^ right);

Paramètres

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

first
Début de la plage à insérer.

last
Fin de la plage à insérer.

right
Énumération à insérer.

val
Valeur de l’élément à insérer.

where
Emplacement dans le conteneur à insérer avant.

Notes

Chacune des fonctions membres insère, avant l’élément pointé vers l’endroit où , 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 avec valeur val et retourne un itérateur qui désigne l’élément nouvellement inséré. Vous l’utilisez pour insérer un élément unique avant un emplacement désigné par un itérateur.

La deuxième fonction membre insère une répétition de nombre d’éléments de valeur val. Vous l’utilisez pour insérer zéro ou plusieurs éléments contigus qui sont toutes des copies de la même valeur.

Si InIt est un type entier, la troisième fonction membre se comporte comme insert(where, (size_type)first, (value_type)last). Sinon, il insère la séquence [first, last). Vous l’utilisez pour insérer zéro ou plusieurs éléments contigus copiés à partir d’une autre séquence.

La quatrième fonction membre insère la séquence désignée par la droite. Vous l’utilisez pour insérer une séquence décrite par un énumérateur.

Lors de l’insertion d’un élément unique, le nombre de copies d’éléments est linéaire dans le nombre d’éléments entre le point d’insertion et la fin la plus proche de la séquence. (Lors de l’insertion d’un ou de plusieurs éléments à la fin de la séquence, aucun élément ne se produit.) S’il InIt s’agit d’un itérateur d’entrée, la troisième fonction membre effectue efficacement une insertion unique pour chaque élément de la séquence. Sinon, lors de l’insertion d’éléments N , le nombre de copies d’éléments est linéaire en N plus du nombre d’éléments entre le point d’insertion et la fin plus proche de la séquence.

Exemple

// cliext_list_insert.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert a single value using iterator
    cliext::list<wchar_t>::iterator it = c1.begin();
    System::Console::WriteLine("insert(begin()+1, L'x') = {0}",
        *c1.insert(++it, L'x'));
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert a repetition of values
    cliext::list<wchar_t> c2;
    c2.insert(c2.begin(), 2, L'y');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert an iterator range
    it = c1.end();
    c2.insert(c2.end(), c1.begin(), --it);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert an enumeration
    c2.insert(c2.begin(),   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c1);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // insert a single value using index
    it = c2.begin();
    ++it, ++it, ++it;
    c2.insert(it, L'z');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    return (0);
    }

a b c
insert(begin()+1, L'x') = x
a x b c
y y
y y a x b
a x b c y y a x b

list::iterator (STL/CLR)

Type d'un itérateur pour la séquence contrôlée.

Syntaxe

typedef T1 iterator;

Notes

Le type décrit un objet de type T1 non spécifié qui peut servir d’itérateur d’accès aléatoire pour la séquence contrôlée.

Exemple

// cliext_list_iterator.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    cliext::list<wchar_t>::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();

    // alter first element and redisplay
    it = c1.begin();
    *it = L'x';
    for (; it != c1.end(); ++it)
        System::Console::Write("{0} ", *it);
    System::Console::WriteLine();
    return (0);
    }

a b c
x b c

list::list (STL/CLR)

Construit un objet conteneur.

Syntaxe

list();
list(list<Value>% right);
list(list<Value>^ right);
explicit list(size_type count);
list(size_type count, value_type val);
template<typename InIt>
    list(InIt first, InIt last);
list(System::Collections::Generic::IEnumerable<Value>^ right);

Paramètres

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

first
Début de la plage à insérer.

last
Fin de la plage à insérer.

right
Objet ou plage à insérer.

val
Valeur de l’élément à insérer.

Notes

Constructeur :

list();

initialise la séquence contrôlée sans éléments. Vous l’utilisez pour spécifier une séquence contrôlée initiale vide.

Constructeur :

list(list<Value>% right);

initialise la séquence contrôlée avec la séquence [right.begin(), right.end()). Vous l’utilisez pour spécifier une séquence contrôlée initiale qui est une copie de la séquence contrôlée par la droite de l’objet de liste.

Constructeur :

list(list<Value>^ right);

initialise la séquence contrôlée avec la séquence [right->begin(), right->end()). Vous l’utilisez pour spécifier une séquence contrôlée initiale qui est une copie de la séquence contrôlée par l’objet de liste dont le handle est correct.

Constructeur :

explicit list(size_type count);

initialise la séquence contrôlée avec des éléments de nombre chacun avec la valeur value_type(). Vous l’utilisez pour remplir le conteneur avec des éléments qui ont toutes la valeur par défaut.

Constructeur :

list(size_type count, value_type val);

initialise la séquence contrôlée avec des éléments de nombre chacun avec valeur val. Vous l’utilisez pour remplir le conteneur avec des éléments ayant toutes la même valeur.

Constructeur :

template<typename InIt>

list(InIt first, InIt last);

initialise la séquence contrôlée avec la séquence [first, last). Vous l’utilisez pour faire de la séquence contrôlée une copie d’une autre séquence.

Constructeur :

list(System::Collections::Generic::IEnumerable<Value>^ right);

initialise la séquence contrôlée avec la séquence désignée par la droite de l’énumérateur. Vous l’utilisez pour rendre la séquence contrôlée une copie d’une autre séquence décrite par un énumérateur.

Exemple

// cliext_list_construct.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
// construct an empty container
    cliext::list<wchar_t> c1;
    System::Console::WriteLine("size() = {0}", c1.size());

    // construct with a repetition of default values
    cliext::list<wchar_t> c2(3);
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", (int)elem);
    System::Console::WriteLine();

    // construct with a repetition of values
    cliext::list<wchar_t> c3(6, L'x');
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an iterator range
    cliext::list<wchar_t>::iterator it = c3.end();
    cliext::list<wchar_t> c4(c3.begin(), --it);
    for each (wchar_t elem in c4)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct with an enumeration
    cliext::list<wchar_t> c5(   // NOTE: cast is not needed
        (System::Collections::Generic::IEnumerable<wchar_t>^)%c3);
    for each (wchar_t elem in c5)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying another container
    cliext::list<wchar_t> c7(c3);
    for each (wchar_t elem in c7)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct by copying a container handle
    cliext::list<wchar_t> c8(%c3);
    for each (wchar_t elem in c8)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    return (0);
    }

size() = 0
0 0 0
x x x x x x
x x x x x
x x x x x x
x x x x x x
x x x x x x

list::merge (STL/CLR)

Fusionne deux séquences contrôlées ordonnées.

Syntaxe

void merge(list<Value>% right);
template<typename Pred2>
    void merge(list<Value>% right, Pred2 pred);

Paramètres

Pred
Comparateur pour les paires d’éléments.

right
Conteneur à fusionner.

Notes

La première fonction membre supprime tous les éléments de la séquence contrôlée par droite et les insère dans la séquence contrôlée. Les deux séquences doivent être précédemment ordonnées par operator< les éléments : les éléments ne doivent pas diminuer de valeur au fur et à mesure que vous progressez dans l’une ou l’autre séquence. La séquence résultante est également ordonnée par operator<. Vous utilisez cette fonction membre pour fusionner deux séquences qui augmentent la valeur dans une séquence qui augmente également la valeur.

La deuxième fonction membre se comporte comme la première, sauf que les séquences sont ordonnées par pred -- pred(X, Y) false pour tout élément X qui suit l’élément Y de la séquence. Vous l’utilisez pour fusionner deux séquences ordonnées par une fonction de prédicat ou un délégué que vous spécifiez.

Les deux fonctions effectuent une fusion stable : aucune paire d’éléments dans l’une des séquences contrôlées d’origine n’est inversée dans la séquence contrôlée résultante. En outre, si une paire d’éléments X et Y dans la séquence contrôlée résultante a un ordre équivalent - !(X < Y) && !(X < Y) - 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 droite.

Exemple

// cliext_list_merge.cpp
// compile with: /clr
#include <cliext/list>

typedef cliext::list<wchar_t> Mylist;
int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'c');
    c1.push_back(L'e');

    // display initial contents " a c e"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    cliext::list<wchar_t> c2;
    c2.push_back(L'b');
    c2.push_back(L'd');
    c2.push_back(L'f');

    // display initial contents " b d f"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // merge and display
    cliext::list<wchar_t> c3(c1);
    c3.merge(c2);
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("c2.size() = {0}", c2.size());

    // sort descending, merge descending, and redisplay
    c1.sort(cliext::greater<wchar_t>());
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    c3.sort(cliext::greater<wchar_t>());
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    c3.merge(c1, cliext::greater<wchar_t>());
    for each (wchar_t elem in c3)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("c1.size() = {0}", c1.size());
    return (0);
    }

a c e
b d f
a b c d e f
c2.size() = 0
e c a
f e d c b a
f e e d c c b a a
c1.size() = 0

list::operator= (STL/CLR)

Remplace la séquence contrôlée.

Syntaxe

list<Value>% operator=(list<Value>% right);

Paramètres

right
Conteneur à copier.

Notes

L’opérateur membre copie le droit vers l’objet, puis retourne *this. Vous l’utilisez pour remplacer la séquence contrôlée par une copie de la séquence contrôlée à droite.

Exemple

// cliext_list_operator_as.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::list<wchar_t> c2;
    c2 = c1;
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c

list::pop_back (STL/CLR)

Supprime le dernier élément.

Syntaxe

void pop_back();

Notes

La fonction membre supprime le dernier élément de la séquence contrôlée, qui doit être non vide. Vous l’utilisez pour raccourcir la liste d’un élément à l’arrière.

Exemple

// cliext_list_pop_back.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // pop an element and redisplay
    c1.pop_back();
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b

list::pop_front (STL/CLR)

Supprime le premier élément.

Syntaxe

void pop_front();

Notes

La fonction membre supprime le premier élément de la séquence contrôlée, qui doit être non vide. Vous l’utilisez pour raccourcir la liste d’un élément à l’avant.

Exemple

// cliext_list_pop_front.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // pop an element and redisplay
    c1.pop_front();
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
b c

list::push_back (STL/CLR)

Ajoute un nouvel élément.

Syntaxe

void push_back(value_type val);

Notes

La fonction membre insère un élément avec une valeur val à la fin de la séquence contrôlée. Vous l’utilisez pour ajouter un autre élément à la liste.

Exemple

// cliext_list_push_back.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c

list::push_front (STL/CLR)

Ajoute un nouvel élément.

Syntaxe

void push_front(value_type val);

Notes

La fonction membre insère un élément avec une valeur val au début de la séquence contrôlée. Vous l’utilisez pour ajouter un autre élément à la liste.

Exemple

// cliext_list_push_front.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_front(L'a');
    c1.push_front(L'b');
    c1.push_front(L'c');

    // display contents " c b a"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

c b a

list::rbegin (STL/CLR)

Désigne le début de la séquence contrôlée inverse.

Syntaxe

reverse_iterator rbegin();

Notes

La fonction membre retourne un itérateur inverse qui désigne le dernier élément de la séquence contrôlée, ou juste au-delà du début d’une séquence vide. Par conséquent, il désigne la beginning séquence inverse. Vous l’utilisez pour obtenir un itérateur qui désigne le current début de la séquence contrôlée vue dans l’ordre inverse, mais son état peut changer si la longueur de la séquence contrôlée change.

Exemple

// cliext_list_rbegin.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items in reversed sequence
    cliext::list<wchar_t>::reverse_iterator rit = c1.rbegin();
    System::Console::WriteLine("*rbegin() = {0}", *rit);
    System::Console::WriteLine("*++rbegin() = {0}", *++rit);

    // alter first two items and reinspect
    *--rit = L'x';
    *++rit = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*rbegin() = c
*++rbegin() = b
a y x

list::reference (STL/CLR)

Type d'une référence à un élément.

Syntaxe

typedef value_type% reference;

Notes

Le type décrit une référence à un élément.

Exemple

// cliext_list_reference.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    cliext::list<wchar_t>::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        cliext::list<wchar_t>::reference ref = *it;
        System::Console::Write("{0} ", ref);
        }
    System::Console::WriteLine();

    // modify contents " a b c"
    for (it = c1.begin(); it != c1.end(); ++it)
        {   // get a reference to an element
        cliext::list<wchar_t>::reference ref = *it;

        ref += (wchar_t)(L'A' - L'a');
        System::Console::Write("{0} ", ref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c
A B C

list::remove (STL/CLR)

Supprime un élément avec une valeur spécifiée.

Syntaxe

void remove(value_type val);

Paramètres

val
Valeur de l’élément à supprimer.

Notes

La fonction membre supprime un élément de la séquence contrôlée pour laquelle ((System::Object^)val)->Equals((System::Object^)x) la valeur est true (le cas échéant). Vous l’utilisez pour effacer un élément arbitraire avec la valeur spécifiée.

Exemple

// cliext_list_remove.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // fail to remove and redisplay
    c1.remove(L'A');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // remove and redisplay
    c1.remove(L'b');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
a b c
a c

list::remove_if (STL/CLR)

Supprime les éléments qui passent un test spécifié.

Syntaxe

template<typename Pred1>
    void remove_if(Pred1 pred);

Paramètres

Pred
Testez les éléments à supprimer.

Notes

La fonction membre supprime de la séquence contrôlée (efface) chaque élément X dont pred(X) la valeur est true. Vous l’utilisez pour supprimer tous les éléments qui répondent à une condition que vous spécifiez en tant que fonction ou délégué.

Exemple

// cliext_list_remove_if.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'b');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b b b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // fail to remove and redisplay
    c1.remove_if(cliext::binder2nd<cliext::equal_to<wchar_t> >(
        cliext::equal_to<wchar_t>(), L'd'));
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // remove and redisplay
    c1.remove_if(cliext::binder2nd<cliext::not_equal_to<wchar_t> >(
        cliext::not_equal_to<wchar_t>(), L'b'));
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b b b c
a b b b c
b b b

list::rend (STL/CLR)

Désigne la fin de la séquence contrôlée inverse.

Syntaxe

reverse_iterator rend();

Notes

La fonction membre retourne un itérateur inverse qui pointe juste au-delà du début de la séquence contrôlée. Par conséquent, il désigne la end séquence inverse. Vous l’utilisez pour obtenir un itérateur qui désigne la current fin de la séquence contrôlée vue dans l’ordre inverse, mais son état peut changer si la longueur de la séquence contrôlée change.

Exemple

// cliext_list_rend.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // inspect first two items
    cliext::list<wchar_t>::reverse_iterator rit = c1.rend();
    --rit;
    System::Console::WriteLine("*-- --rend() = {0}", *--rit);
    System::Console::WriteLine("*--rend() = {0}", *++rit);

    // alter first two items and reinspect
    *--rit = L'x';
    *++rit = L'y';
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
*-- --rend() = b
*--rend() = a
y x c

list::resize (STL/CLR)

Modifie le nombre d’éléments.

Syntaxe

void resize(size_type new_size);
void resize(size_type new_size, value_type val);

Paramètres

new_size
Nouvelle taille de la séquence contrôlée.

val
Valeur de l’élément de remplissage.

Notes

Les fonctions membres garantissent tous deux que list ::size (STL/CLR)() retourne désormais new_size. Si elle doit rendre la séquence contrôlée plus longue, la première fonction membre ajoute des éléments avec valeur value_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 effacent efficacement les dernières heures de liste d’éléments ::size (STL/CLR).() - new_size Vous l’utilisez pour vous assurer que la séquence contrôlée a une taille new_size, en rognant ou en remplissage de la séquence contrôlée actuelle.

Exemple

// cliext_list_resize.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
// construct an empty container and pad with default values
    cliext::list<wchar_t> c1;
    System::Console::WriteLine("size() = {0}", c1.size());
    c1.resize(4);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", (int)elem);
    System::Console::WriteLine();

    // resize to empty
    c1.resize(0);
    System::Console::WriteLine("size() = {0}", c1.size());

    // resize and pad
    c1.resize(5, L'x');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

size() = 0
0 0 0 0
size() = 0
x x x x x

list::reverse (STL/CLR)

Inverse la séquence contrôlée.

Syntaxe

void reverse();

Notes

La fonction membre inverse l’ordre de tous les éléments de la séquence contrôlée. Vous l’utilisez pour refléter une liste d’éléments.

Exemple

// cliext_list_reverse.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // reverse and redisplay
    c1.reverse();
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
c b a

list::reverse_iterator (STL/CLR)

Type d'un itérateur inverse pour la séquence contrôlée.

Syntaxe

typedef T3 reverse_iterator;

Notes

Le type décrit un objet de type T3 non spécifié qui peut servir d’itérateur inverse pour la séquence contrôlée.

Exemple

// cliext_list_reverse_iterator.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" reversed
    cliext::list<wchar_t>::reverse_iterator rit = c1.rbegin();
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();

    // alter first element and redisplay
    rit = c1.rbegin();
    *rit = L'x';
    for (; rit != c1.rend(); ++rit)
        System::Console::Write("{0} ", *rit);
    System::Console::WriteLine();
    return (0);
    }

c b a
x b a

list::size (STL/CLR)

Compte le nombre d'éléments.

Syntaxe

size_type size();

Notes

La fonction membre retourne la longueur de la séquence contrôlée. Vous l’utilisez pour déterminer le nombre d’éléments actuellement dans la séquence contrôlée. Si vous vous souciez tous de savoir si la séquence a une taille différente de zéro, consultez list ::empty (STL/CLR)().

Exemple

// cliext_list_size.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("size() = {0} starting with 3", c1.size());

    // clear the container and reinspect
    c1.clear();
    System::Console::WriteLine("size() = {0} after clearing", c1.size());

    // add elements and clear again
    c1.push_back(L'a');
    c1.push_back(L'b');
    System::Console::WriteLine("size() = {0} after adding 2", c1.size());
    return (0);
    }

a b c
size() = 3 starting with 3
size() = 0 after clearing
size() = 2 after adding 2

list::size_type (STL/CLR)

Type d’une distance signée entre deux éléments.

Syntaxe

typedef int size_type;

Notes

Le type décrit un nombre d’éléments non négatifs.

Exemple

// cliext_list_size_type.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // compute positive difference
    cliext::list<wchar_t>::size_type diff = 0;
    for (cliext::list<wchar_t>::iterator it = c1.begin();
        it != c1.end(); ++it)
        ++diff;
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }

a b c
end()-begin() = 3

list::sort (STL/CLR)

Commande la séquence contrôlée.

Syntaxe

void sort();
template<typename Pred2>
    void sort(Pred2 pred);

Paramètres

Pred
Comparateur pour les paires d’éléments.

Notes

La première fonction membre réorganise les éléments de la séquence contrôlée afin qu’ils soient classés par operator< -- les éléments ne diminuent pas de valeur lorsque vous progressez dans la séquence. Vous utilisez cette fonction membre pour trier la séquence dans l’ordre croissant.

La deuxième fonction membre se comporte de la même façon que la première, sauf que la séquence est ordonnée par pred -- pred(X, Y) false pour tout élément X qui suit l’élément Y dans la séquence résultante. Vous l’utilisez pour trier la séquence dans un ordre que vous spécifiez par une fonction ou un délégué de prédicat.

Les deux fonctions effectuent un tri stable : 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 résultante.

Exemple

// cliext_list_sort.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // sort descending and redisplay
    c1.sort(cliext::greater<wchar_t>());
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // sort ascending and redisplay
    c1.sort();
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
c b a
a b c

list::splice (STL/CLR)

Liens restitch entre nœuds.

Syntaxe

void splice(iterator where, list<Value>% right);
void splice(iterator where, list<Value>% right,
    iterator first);
void splice(iterator where, list<Value>% right,
    iterator first, iterator last);

Paramètres

first
Début de la plage à splice.

last
Fin de la plage à splice.

right
Conteneur à partir duquel splice.

where
Où se trouve le conteneur pour splice avant.

Notes

La première fonction membre insère la séquence contrôlée par juste avant l’élément de la séquence contrôlée pointée vers où. Il supprime également tous les éléments de droite. (%right ne doit pas être égal thisà .) Vous l’utilisez pour splicer toutes les listes dans une autre.

La deuxième fonction membre supprime l’élément pointé d’abord dans la séquence contrôlée par droite et l’insère avant l’élément de la séquence contrôlée pointée vers où. (Si where == first || where == ++first, aucune modification ne se produit.) Vous l’utilisez pour splicer un élément unique d’une liste dans une autre.

La troisième fonction membre insère la sous-plage désignée par [first, last) de la séquence contrôlée par juste avant l’élément de la séquence contrôlée pointée vers où. Elle supprime également la sous-plage d’origine de la séquence contrôlée par droite. (Si right == this, la plage [first, last) ne doit pas inclure l’élément pointé vers l’emplacement où.) Vous l’utilisez pour ajouter une sous-séquence de zéro ou plusieurs éléments d’une liste à une autre.

Exemple

// cliext_list_splice.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // splice to a new list
    cliext::list<wchar_t> c2;
    c2.splice(c2.begin(), c1);
    System::Console::WriteLine("c1.size() = {0}", c1.size());
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // return one element
    c1.splice(c1.end(), c2, c2.begin());
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // return remaining elements
    c1.splice(c1.begin(), c2, c2.begin(), c2.end());
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    System::Console::WriteLine("c2.size() = {0}", c2.size());
    return (0);
    }

a b c
c1.size() = 0
a b c
a
b c
b c a
c2.size() = 0

list::swap (STL/CLR)

Échange le contenu de deux conteneurs.

Syntaxe

void swap(list<Value>% right);

Paramètres

right
Conteneur avec lequel échanger le contenu.

Notes

La fonction membre échange les séquences contrôlées entre *this et droite. Il le fait en temps constant et ne lève aucune exception. Vous l’utilisez comme moyen rapide d’échanger le contenu de deux conteneurs.

Exemple

// cliext_list_swap.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // construct another container with repetition of values
    cliext::list<wchar_t> c2(5, L'x');
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // swap and redisplay
    c1.swap(c2);
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c
x x x x x
x x x x x
a b c

list::to_array (STL/CLR)

Copie la séquence contrôlée dans un nouveau tableau.

Syntaxe

cli::array<Value>^ to_array();

Notes

La fonction membre retourne un tableau contenant la séquence contrôlée. Vous l’utilisez pour obtenir une copie de la séquence contrôlée sous forme de tableau.

Exemple

// cliext_list_to_array.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // copy the container and modify it
    cli::array<wchar_t>^ a1 = c1.to_array();

    c1.push_back(L'd');
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display the earlier array copy
    for each (wchar_t elem in a1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a b c d
a b c

list::unique (STL/CLR)

Supprime des éléments adjacents qui réussissent un test spécifié.

Syntaxe

void unique();
template<typename Pred2>
    void unique(Pred2 pred);

Paramètres

Pred
Comparateur pour les paires d’éléments.

Notes

La première fonction membre supprime de la séquence contrôlée (efface) chaque élément qui compare à son élément précédent - si l’élément X précède l’élément Y et X == Y, la fonction membre supprime Y. Vous l’utilisez pour supprimer toutes les copies de toutes les sous-séquences d’éléments adjacents qui comparent égales. Notez que si la séquence contrôlée est ordonnée, par exemple en appelant list ::sort (STL/CLR),() la fonction membre laisse uniquement des éléments avec des valeurs uniques. (D’où leur nom.)

La deuxième fonction membre se comporte de la même façon que la première, sauf qu’elle supprime chaque élément Y suivant un élément X pour lequel pred(X, Y). Vous l’utilisez pour supprimer toutes les copies de toutes les sous-séquences d’éléments adjacents qui répondent à une fonction de prédicat ou un délégué que vous spécifiez. Notez que si la séquence contrôlée est ordonnée, par exemple en appelant sort(pred), la fonction membre laisse uniquement les éléments qui n’ont pas d’ordre équivalent avec d’autres éléments.

Exemple

// cliext_list_unique.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display initial contents " a a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display contents after unique
    cliext::list<wchar_t> c2(c1);
    c2.unique();
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // display contents after unique(not_equal_to)
    c2 = c1;
    c2.unique(cliext::not_equal_to<wchar_t>());
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();
    return (0);
    }

a a b c
a b c
a a

list::value_type (STL/CLR)

Type d’un élément.

Syntaxe

typedef Value value_type;

Notes

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

Exemple

// cliext_list_value_type.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c" using value_type
    for (cliext::list<wchar_t>::iterator it = c1.begin();
        it != c1.end(); ++it)
        {   // store element in value_type object
        cliext::list<wchar_t>::value_type val = *it;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

operator!= (list) (STL/CLR)

Lister les comparaisons non égales.

Syntaxe

template<typename Value>
    bool operator!=(list<Value>% left,
        list<Value>% right);

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction d’opérateur retourne !(left == right). Vous l’utilisez pour tester si la gauche n’est pas ordonnée de la même façon que la droite lorsque les deux listes sont comparées par élément.

Exemple

// cliext_list_operator_ne.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::list<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] != [a b c] is {0}",
        c1 != c1);
    System::Console::WriteLine("[a b c] != [a b d] is {0}",
        c1 != c2);
    return (0);
    }

a b c
a b d
[a b c] != [a b c] is False
[a b c] != [a b d] is True

`operator<` (liste) (STL/CLR)

Liste inférieure à la comparaison.

Syntaxe

template<typename Value>
    bool operator<(list<Value>% left,
        list<Value>% right);

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction d’opérateur retourne true si, pour la position i la plus basse pour laquelle !(right[i] < left[i]) il est également vrai que left[i] < right[i]. Sinon, elle retourne left->size() < right->size() vous permet de tester si la gauche est ordonnée avant la droite lorsque les deux listes sont comparées par élément.

Exemple

// cliext_list_operator_lt.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::list<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] < [a b c] is {0}",
        c1 < c1);
    System::Console::WriteLine("[a b c] < [a b d] is {0}",
        c1 < c2);
    return (0);
    }

a b c
a b d
[a b c] < [a b c] is False
[a b c] < [a b d] is True

`operator<=` (liste) (STL/CLR)

Liste inférieure ou égale à la comparaison.

Syntaxe

template<typename Value>
    bool operator<=(list<Value>% left,
        list<Value>% right);

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction d’opérateur retourne !(right < left). Vous l’utilisez pour tester si la gauche n’est pas ordonnée après la droite lorsque les deux listes sont comparées par élément.

Exemple

// cliext_list_operator_le.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::list<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] <= [a b c] is {0}",
        c1 <= c1);
    System::Console::WriteLine("[a b d] <= [a b c] is {0}",
        c2 <= c1);
    return (0);
    }

a b c
a b d
[a b c] <= [a b c] is True
[a b d] <= [a b c] is False

operator== (list) (STL/CLR)

Lister la comparaison égale.

Syntaxe

template<typename Value>
    bool operator==(list<Value>% left,
        list<Value>% right);

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction opérateur retourne true uniquement si les séquences contrôlées par gauche et droite ont la même longueur et, pour chaque position i, left[i] == right[i]. Vous l’utilisez pour tester si la gauche est ordonnée de la même façon que la droite lorsque les deux listes sont comparées par élément.

Exemple

// cliext_list_operator_eq.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::list<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] == [a b c] is {0}",
        c1 == c1);
    System::Console::WriteLine("[a b c] == [a b d] is {0}",
        c1 == c2);
    return (0);
    }

a b c
a b d
[a b c] == [a b c] is True
[a b c] == [a b d] is False

`operator>` (liste) (STL/CLR)

Liste supérieure à la comparaison.

Syntaxe

template<typename Value>
    bool operator>(list<Value>% left,
        list<Value>% right);

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction d’opérateur retourne right < left. Vous l’utilisez pour tester si la gauche est ordonnée après la droite lorsque les deux listes sont comparées par élément.

Exemple

// cliext_list_operator_gt.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::list<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] > [a b c] is {0}",
        c1 > c1);
    System::Console::WriteLine("[a b d] > [a b c] is {0}",
        c2 > c1);
    return (0);
    }

a b c
a b d
[a b c] > [a b c] is False
[a b d] > [a b c] is True

`operator>=` (liste) (STL/CLR)

Liste supérieure ou égale à la comparaison.

Syntaxe

template<typename Value>
    bool operator>=(list<Value>% left,
        list<Value>% right);

Paramètres

left
Conteneur de gauche à comparer.

right
Conteneur de droite à comparer.

Notes

La fonction d’opérateur retourne !(left < right). Vous l’utilisez pour tester si la gauche n’est pas ordonnée avant la droite lorsque les deux listes sont comparées par élément.

Exemple

// cliext_list_operator_ge.cpp
// compile with: /clr
#include <cliext/list>

int main()
    {
    cliext::list<wchar_t> c1;
    c1.push_back(L'a');
    c1.push_back(L'b');
    c1.push_back(L'c');

    // display contents " a b c"
    for each (wchar_t elem in c1)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    // assign to a new container
    cliext::list<wchar_t> c2;
    c2.push_back(L'a');
    c2.push_back(L'b');
    c2.push_back(L'd');

    // display contents " a b d"
    for each (wchar_t elem in c2)
        System::Console::Write("{0} ", elem);
    System::Console::WriteLine();

    System::Console::WriteLine("[a b c] >= [a b c] is {0}",
        c1 >= c1);
    System::Console::WriteLine("[a b c] >= [a b d] is {0}",
        c1 >= c2);
    return (0);
    }

a b c
a b d
[a b c] >= [a b c] is True
[a b c] >= [a b d] is False

Partager via

list (STL/CLR)

Syntaxe

Paramètres

Spécifications

Déclarations

Interfaces

Notes

Membres

list::assign (STL/CLR)

Syntaxe

Paramètres

Notes

Exemple

list::back (STL/CLR)

Syntaxe

Notes

Exemple

list::back_item (STL/CLR)

Syntaxe

Notes

Exemple

list::begin (STL/CLR)

Syntaxe

Notes

Exemple

list::clear (STL/CLR)

Syntaxe

Notes

Exemple

list::const_iterator (STL/CLR)

Syntaxe

Notes

Exemple

list::const_reference (STL/CLR)

Syntaxe

Notes

Exemple

list::const_reverse_iterator (STL/CLR)

Syntaxe

Notes

Exemple

list::difference_type (STL/CLR)

Syntaxe

Notes

Exemple

list::empty (STL/CLR)

Syntaxe

Notes

Exemple

list::end (STL/CLR)

Syntaxe

Notes

Exemple

list::erase (STL/CLR)

Syntaxe

Paramètres

Notes

Exemple

list::front (STL/CLR)

Syntaxe

Notes

Exemple

list::front_item (STL/CLR)

Syntaxe

Notes

Exemple

list::generic_container (STL/CLR)

Syntaxe

Notes

Exemple

list::generic_iterator (STL/CLR)

Syntaxe

Notes

Exemple

list::generic_reverse_iterator (STL/CLR)

Syntaxe

Notes

Exemple

list::generic_value (STL/CLR)