list (STL/CLR)

Articolo
10/12/2023

La classe modello descrive un oggetto che controlla una sequenza di elementi di lunghezza variabile con accesso bidirezionale. Il contenitore list viene usato per gestire una sequenza di elementi come elenco di nodi collegati bidirezionali, ognuno dei quali archivia un elemento.

Nella descrizione seguente GValue , è uguale a Value a meno che quest'ultimo non sia un tipo ref, nel qual caso è Value^.

Sintassi

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>
    { ..... };

Parametri

valore
Tipo di un elemento nella sequenza controllata.

Requisiti

Intestazione:<cliext/list>

Spazio dei nomi: cliext

Dichiarazioni

Definizione del tipo	Descrizione
list::const_iterator (STL/CLR)	Tipo di un iteratore costante per la sequenza controllata.
list::const_reference (STL/CLR)	Tipo di un riferimento costante a un elemento.
list::const_reverse_iterator (STL/CLR)	Tipo di un iteratore inverso costante per la sequenza controllata.
list::difference_type (STL/CLR)	Tipo di una distanza Signed tra due elementi.
list::generic_container (STL/CLR)	Tipo dell'interfaccia generica per il contenitore.
list::generic_iterator (STL/CLR)	Tipo di iteratore per l'interfaccia generica per il contenitore.
list::generic_reverse_iterator (STL/CLR)	Tipo di iteratore inverso per l'interfaccia generica per il contenitore.
list::generic_value (STL/CLR)	Tipo di elemento per l'interfaccia generica per il contenitore.
list::iterator (STL/CLR)	Tipo di un iteratore per la sequenza controllata.
list::reference (STL/CLR)	Tipo di un riferimento a un elemento.
list::reverse_iterator (STL/CLR)	Tipo di un iteratore inverso della sequenza controllata.
list::size_type (STL/CLR)	Tipo di una distanza Signed tra due elementi.
list::value_type (STL/CLR)	Tipo di un elemento.

Funzione membro	Descrizione
list::assign (STL/CLR)	Sostituisce tutti gli elementi.
list::back (STL/CLR)	Accede all'ultimo elemento.
list::begin (STL/CLR)	Indica l'inizio della sequenza controllata.
list::clear (STL/CLR)	Rimuove tutti gli elementi.
list::empty (STL/CLR)	Verifica se sono presenti o meno degli elementi.
list::end (STL/CLR)	Designa la fine della sequenza controllata.
list::erase (STL/CLR)	Rimuove gli elementi in corrispondenza delle posizioni specificate.
list::front (STL/CLR)	Accede al primo elemento.
list::insert (STL/CLR)	Aggiunge elementi in una posizione specificata.
list::list (STL/CLR)	Costruisce un oggetto contenitore.
list::merge (STL/CLR)	Unisce due sequenze controllate ordinate.
list::pop_back (STL/CLR)	Rimuove l'ultimo elemento.
list::pop_front (STL/CLR)	Rimuove il primo elemento.
list::push_back (STL/CLR)	Aggiunge un nuovo ultimo elemento.
list::push_front (STL/CLR)	Aggiunge un nuovo primo elemento.
list::rbegin (STL/CLR)	Indica l'inizio della sequenza controllata inversa.
list::remove (STL/CLR)	Rimuove un elemento con un valore specificato.
list::remove_if (STL/CLR)	Rimuove gli elementi che superano un test specificato.
list::rend (STL/CLR)	Indica la fine della sequenza controllata inversa.
list::resize (STL/CLR)	Modifica il numero di elementi.
list::reverse (STL/CLR)	Inverte la sequenza controllata.
list::size (STL/CLR)	Conta il numero di elementi.
list::sort (STL/CLR)	Ordina la sequenza controllata.
list::splice (STL/CLR)	Unisce di nuovo i collegamenti tra nodi.
list::swap (STL/CLR)	Scambia il contenuto di due contenitori.
list::to_array (STL/CLR)	Copia la sequenza controllata in una nuova matrice.
list::unique (STL/CLR)	Rimuove gli elementi adiacenti che superano un test specificato.

Proprietà	Descrizione
list::back_item (STL/CLR)	Accede all'ultimo elemento.
list::front_item (STL/CLR)	Accede al primo elemento.

Operatore	Descrizione
list::operator= (STL/CLR)	Sostituisce la sequenza controllata.
operator!= (list) (STL/CLR)	Determina se un `list` oggetto non è uguale a un altro `list` oggetto.
operator< (list) (STL/CLR)	Determina se un `list` oggetto è minore di un altro `list` oggetto.
operator<= (list) (STL/CLR)	Determina se un `list` oggetto è minore o uguale a un altro `list` oggetto.
operator== (list) (STL/CLR)	Determina se un `list` oggetto è uguale a un altro `list` oggetto.
operator> (list) (STL/CLR)	Determina se un `list` oggetto è maggiore di un altro `list` oggetto.
operator>= (list) (STL/CLR)	Determina se un `list` oggetto è maggiore o uguale a un altro `list` oggetto.

Interfacce

Interfaccia	Descrizione
ICloneable	Duplicare un oggetto .
IEnumerable	Sequenzia tra elementi.
ICollection	Mantenere il gruppo di elementi.
IEnumerable<T>	Sequenzia tra elementi tipizzato.
ICollection<T>	Mantenere un gruppo di elementi tipizzato.
Valore IList<>	Gestire un contenitore generico.

Osservazioni:

L'oggetto alloca e libera l'archiviazione per la sequenza che controlla come singoli nodi in un elenco di collegamenti bidirezionali. Riorganizzare gli elementi modificando i collegamenti tra i nodi, non copiando mai il contenuto di un nodo in un altro. Ciò significa che è possibile inserire e rimuovere liberamente elementi senza disturbare gli elementi rimanenti. Un elenco è quindi un buon candidato per il contenitore sottostante per la coda di classi modello (STL/CLR) o lo stack di classi modello (STL/CLR).

Un list oggetto supporta iteratori bidirezionali, il che significa che è possibile passare agli elementi adiacenti in base a un iteratore che designa un elemento nella sequenza controllata. Un nodo head speciale corrisponde all'iteratore restituito da list::end (STL/CLR).() È possibile decrementare questo iteratore per raggiungere l'ultimo elemento nella sequenza controllata, se presente. È possibile incrementare un iteratore di elenco per raggiungere il nodo head e quindi confrontarlo con end(). Ma non è possibile dereferenziare l'iteratore restituito da end().

Si noti che non è possibile fare riferimento a un elemento elenco direttamente in base alla relativa posizione numerica, che richiede un iteratore ad accesso casuale. Pertanto, un elenco non è utilizzabile come contenitore sottostante per la classe modello priority_queue (STL/CLR).

Un iteratore di elenco archivia un handle per il nodo elenco associato, che a sua volta archivia un handle nel contenitore associato. È possibile usare gli iteratori solo con gli oggetti contenitore associati. Un iteratore di elenco rimane valido fino a quando il nodo elenco associato è associato a un elenco. Inoltre, un iteratore valido è dereferenziabile - è possibile usarlo per accedere o modificare il valore dell'elemento designato - purché non sia uguale a end().

Cancellare o rimuovere un elemento chiama il distruttore per il valore archiviato. L'eliminazione definitiva del contenitore cancella tutti gli elementi. Pertanto, un contenitore il cui tipo di elemento è una classe ref garantisce che nessun elemento scadeni il contenitore. Si noti, tuttavia, che un contenitore di handle non elimina definitivamente i relativi elementi.

Membri

list::assign (STL/CLR)

Sostituisce tutti gli elementi.

Sintassi

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);

Parametri

count
Numero di elementi da inserire.

first
Inizio dell'intervallo da inserire.

last
Fine dell'intervallo da inserire.

right
Enumerazione da inserire.

val
Valore dell'elemento da inserire.

Osservazioni:

La prima funzione membro sostituisce la sequenza controllata con una ripetizione di elementi count di valore val. È possibile usarlo per riempire il contenitore con tutti gli elementi con lo stesso valore.

Se InIt è un tipo integer, la seconda funzione membro si comporta come assign((size_type)first, (value_type)last). In caso contrario, sostituisce la sequenza controllata con la sequenza [first, last). Viene usato per rendere la sequenza controllata una copia di un'altra sequenza.

La terza funzione membro sostituisce la sequenza controllata con la sequenza designata dal diritto dell'enumeratore. È possibile usarla per rendere la sequenza controllata una copia di una sequenza descritta da un enumeratore.

Esempio

// 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)

Accede all'ultimo elemento.

Sintassi

reference back();

Osservazioni:

La funzione membro restituisce un riferimento all'ultimo elemento della sequenza controllata, che deve essere non vuoto. È possibile usarlo per accedere all'ultimo elemento, quando si sa che esiste.

Esempio

// 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)

Accede all'ultimo elemento.

Sintassi

property value_type back_item;

Osservazioni:

La proprietà accede all'ultimo elemento della sequenza controllata, che deve essere non vuoto. È possibile usarlo per leggere o scrivere l'ultimo elemento, quando si sa che esiste.

Esempio

// 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)

Indica l'inizio della sequenza controllata.

Sintassi

iterator begin();

Osservazioni:

La funzione membro restituisce un iteratore ad accesso casuale che definisce il primo elemento della sequenza controllata o appena oltre la fine di una sequenza vuota. Viene usato per ottenere un iteratore che designa l'inizio current della sequenza controllata, ma il relativo stato può cambiare se la lunghezza della sequenza controllata cambia.

Esempio

// 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)

Rimuove tutti gli elementi.

Sintassi

void clear();

Osservazioni:

La funzione membro chiama in modo efficace list::erase (STL/CLR)(list::begin (STL/CLR)(),list::end (STL/CLR).()) Viene usato per assicurarsi che la sequenza controllata sia vuota.

Esempio

// 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)

Tipo di un iteratore costante per la sequenza controllata.

Sintassi

typedef T2 const_iterator;

Osservazioni:

Il tipo descrive un oggetto di tipo T2 non specificato che può fungere da iteratore costante ad accesso casuale per la sequenza controllata.

Esempio

// 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)

Tipo di un riferimento costante a un elemento.

Sintassi

typedef value_type% const_reference;

Osservazioni:

Il tipo descrive un riferimento costante a un elemento.

Esempio

// 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)

Tipo di iteratore inverso costante per la sequenza controllata.

Sintassi

typedef T4 const_reverse_iterator;

Osservazioni:

Il tipo descrive un oggetto di tipo T4 non specificato che può fungere da iteratore inverso costante per la sequenza controllata.

Esempio

// 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)

Tipi di distanza con segno tra due elementi.

Sintassi

typedef int difference_type;

Osservazioni:

Il tipo descrive un conteggio degli elementi con segno.

Esempio

// 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)

Verifica se sono presenti o meno degli elementi.

Sintassi

bool empty();

Osservazioni:

La funzione membro restituisce true per una sequenza controllata vuota. Equivale a list::size (STL/CLR).() == 0 Viene usato per verificare se l'elenco è vuoto.

Esempio

// 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)

Designa la fine della sequenza controllata.

Sintassi

iterator end();

Osservazioni:

La funzione membro restituisce un iteratore ad accesso casuale che punta appena oltre la fine della sequenza controllata. Lo si usa per ottenere un iteratore che designa la fine della sequenza controllata; lo stato non cambia se la lunghezza della sequenza controllata cambia.

Esempio

// 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)

Rimuove gli elementi in corrispondenza delle posizioni specificate.

Sintassi

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

Parametri

first
Inizio dell'intervallo da cancellare.

last
Fine dell'intervallo da cancellare.

where
Elemento da cancellare.

Osservazioni:

La prima funzione membro rimuove l'elemento della sequenza controllata a cui punta dove. Viene usato per rimuovere un singolo elemento.

La seconda funzione membro rimuove gli elementi della sequenza controllata nell'intervallo [first, last). È possibile usarlo per rimuovere zero o più elementi contigui.

Entrambe le funzioni membro restituiscono un iteratore che designa il primo elemento rimanente oltre qualsiasi elemento rimosso o list::end (STL/CLR)() se tale elemento non esiste.

Quando si cancellano gli elementi, il numero di copie degli elementi è lineare nel numero di elementi tra la fine della cancellazione e la fine più vicina della sequenza. Quando si cancella uno o più elementi alla fine della sequenza, non viene eseguita alcuna copia di elementi.

Esempio

// 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)

Accede al primo elemento.

Sintassi

reference front();

Osservazioni:

La funzione membro restituisce un riferimento al primo elemento della sequenza controllata, che deve essere non vuoto. Lo si usa per leggere o scrivere il primo elemento, quando si sa che esiste.

Esempio

// 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)

Accede al primo elemento.

Sintassi

property value_type front_item;

Osservazioni:

La proprietà accede al primo elemento della sequenza controllata, che deve essere non vuoto. Lo si usa per leggere o scrivere il primo elemento, quando si sa che esiste.

Esempio

// 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)

Tipo dell'interfaccia generica per il contenitore.

Sintassi

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

Osservazioni:

Il tipo descrive l'interfaccia generica per questa classe contenitore modello.

Esempio

// 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)

Tipo di iteratore da usare con l'interfaccia generica per il contenitore.

Sintassi

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

Osservazioni:

Il tipo descrive un iteratore generico che può essere usato con l'interfaccia generica per questa classe contenitore modello.

Esempio

// 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)

Tipo di iteratore inverso da usare con l'interfaccia generica per il contenitore.

Sintassi

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

Osservazioni:

Il tipo descrive un iteratore inverso generico che può essere usato con l'interfaccia generica per questa classe contenitore modello.

Esempio

// 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)

Tipo di un elemento da usare con l'interfaccia generica per il contenitore.

Sintassi

typedef GValue generic_value;

Osservazioni:

Il tipo descrive un oggetto di tipo GValue che descrive il valore dell'elemento archiviato da usare con l'interfaccia generica per questa classe contenitore modello.

Esempio

// 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)

Aggiunge elementi in una posizione specificata.

Sintassi

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);

Parametri

count
Numero di elementi da inserire.

first
Inizio dell'intervallo da inserire.

last
Fine dell'intervallo da inserire.

right
Enumerazione da inserire.

val
Valore dell'elemento da inserire.

where
Posizione nel contenitore da inserire prima.

Osservazioni:

Ognuna delle funzioni membro inserisce, prima dell'elemento a cui punta dove nella sequenza controllata, una sequenza specificata dagli operandi rimanenti.

La prima funzione membro inserisce un elemento con valore val e restituisce un iteratore che designa l'elemento appena inserito. Viene usato per inserire un singolo elemento prima di una posizione designata da un iteratore.

La seconda funzione membro inserisce una ripetizione di elementi count di valore val. Viene usato per inserire zero o più elementi contigui che sono tutte copie dello stesso valore.

Se InIt è di tipo Integer, la terza funzione membro si comporta come insert(where, (size_type)first, (value_type)last). In caso contrario, inserisce la sequenza [first, last). Viene usato per inserire zero o più elementi contigui copiati da un'altra sequenza.

La quarta funzione membro inserisce la sequenza designata dalla destra. Viene usato per inserire una sequenza descritta da un enumeratore.

Quando si inserisce un singolo elemento, il numero di copie degli elementi è lineare nel numero di elementi tra il punto di inserimento e la fine più vicina della sequenza. Quando si inseriscono uno o più elementi alla fine della sequenza, non vengono eseguite copie di elementi. Se InIt è un iteratore di input, la terza funzione membro esegue in modo efficace un singolo inserimento per ogni elemento nella sequenza. In caso contrario, quando si inseriscono N elementi, il numero di copie degli elementi è lineare in N più il numero di elementi tra il punto di inserimento e la fine più vicina della sequenza.

Esempio

// 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)

Tipo di un iteratore per la sequenza controllata.

Sintassi

typedef T1 iterator;

Osservazioni:

Il tipo descrive un oggetto di tipo T1 non specificato che può fungere da iteratore ad accesso casuale per la sequenza controllata.

Esempio

// 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)

Costruisce un oggetto contenitore.

Sintassi

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);

Parametri

count
Numero di elementi da inserire.

first
Inizio dell'intervallo da inserire.

last
Fine dell'intervallo da inserire.

right
Oggetto o un intervallo da inserire.

val
Valore dell'elemento da inserire.

Osservazioni:

Costruttore:

list();

inizializza la sequenza controllata senza elementi. Viene usato per specificare una sequenza controllata iniziale vuota.

Costruttore:

list(list<Value>% right);

inizializza la sequenza controllata con la sequenza [right.begin(), right.end()). Viene usato per specificare una sequenza controllata iniziale che è una copia della sequenza controllata dal diritto dell'oggetto elenco.

Costruttore:

list(list<Value>^ right);

inizializza la sequenza controllata con la sequenza [right->begin(), right->end()). Viene usato per specificare una sequenza controllata iniziale che è una copia della sequenza controllata dall'oggetto elenco il cui handle è corretto.

Costruttore:

explicit list(size_type count);

inizializza la sequenza controllata con gli elementi count ognuno con valore value_type(). Viene usato per riempire il contenitore con tutti gli elementi con il valore predefinito.

Costruttore:

list(size_type count, value_type val);

inizializza la sequenza controllata con gli elementi count ognuno con valore val. È possibile usarlo per riempire il contenitore con tutti gli elementi con lo stesso valore.

Costruttore:

template<typename InIt>

list(InIt first, InIt last);

inizializza la sequenza controllata con la sequenza [first, last). È possibile usarla per rendere la sequenza controllata una copia di un'altra sequenza.

Costruttore:

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

inizializza la sequenza controllata con la sequenza designata dal diritto dell'enumeratore. Viene usata per rendere la sequenza controllata una copia di un'altra sequenza descritta da un enumeratore.

Esempio

// 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)

Unisce due sequenze controllate ordinate.

Sintassi

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

Parametri

Pred
Operatore di confronto per le coppie di elementi.

right
Contenitore in cui eseguire l'unione.

Osservazioni:

La prima funzione membro rimuove tutti gli elementi dalla sequenza controllata da destra e li inserisce nella sequenza controllata. Entrambe le sequenze devono essere ordinate in precedenza in operator< base a : gli elementi non devono diminuire nel valore man mano che si procede in entrambe le sequenze. Anche la sequenza risultante viene ordinata in base a operator<. Questa funzione membro viene usata per unire due sequenze che aumentano di valore in una sequenza che aumenta anche di valore.

La seconda funzione membro si comporta come la prima, ad eccezione del fatto che le sequenze vengono ordinate per pred -- pred(X, Y) deve essere false per qualsiasi elemento che segue l'elemento XY nella sequenza. Viene usato per unire due sequenze ordinate da una funzione predicato o da un delegato specificato.

Entrambe le funzioni eseguono un'unione stabile: nessuna coppia di elementi in una delle sequenze controllate originali viene invertita nella sequenza controllata risultante. Inoltre, se una coppia di elementi X e Y nella sequenza controllata risultante ha un ordinamento equivalente - !(X < Y) && !(X < Y) - un elemento della sequenza controllata originale viene visualizzato prima di un elemento dalla sequenza controllata a destra.

Esempio

// 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)

Sostituisce la sequenza controllata.

Sintassi

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

Parametri

right
Contenitore da copiare.

Osservazioni:

L'operatore membro copia direttamente nell'oggetto , quindi restituisce *this. Lo si usa per sostituire la sequenza controllata con una copia della sequenza controllata a destra.

Esempio

// 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)

Rimuove l'ultimo elemento.

Sintassi

void pop_back();

Osservazioni:

La funzione membro rimuove l'ultimo elemento della sequenza controllata, che deve essere non vuoto. È possibile usarlo per abbreviare l'elenco di un elemento nella parte posteriore.

Esempio

// 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)

Rimuove il primo elemento.

Sintassi

void pop_front();

Osservazioni:

La funzione membro rimuove il primo elemento della sequenza controllata, che deve essere non vuoto. È possibile usarlo per abbreviare l'elenco di un elemento in primo piano.

Esempio

// 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)

Aggiunge un nuovo ultimo elemento.

Sintassi

void push_back(value_type val);

Osservazioni:

La funzione membro inserisce un elemento con valore val alla fine della sequenza controllata. È possibile usarlo per accodare un altro elemento all'elenco.

Esempio

// 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)

Aggiunge un nuovo primo elemento.

Sintassi

void push_front(value_type val);

Osservazioni:

La funzione membro inserisce un elemento con valore val all'inizio della sequenza controllata. Viene usato per anteporre un altro elemento all'elenco.

Esempio

// 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)

Indica l'inizio della sequenza controllata inversa.

Sintassi

reverse_iterator rbegin();

Osservazioni:

La funzione membro restituisce un iteratore inverso che definisce l'ultimo elemento della sequenza controllata o appena oltre l'inizio di una sequenza vuota. Di conseguenza, designa l'oggetto beginning della sequenza inversa. Viene usato per ottenere un iteratore che definisce l'inizio current della sequenza controllata visualizzata in ordine inverso, ma il relativo stato può cambiare se la lunghezza della sequenza controllata cambia.

Esempio

// 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)

Tipo di un riferimento a un elemento.

Sintassi

typedef value_type% reference;

Osservazioni:

Il tipo descrive un riferimento a un elemento.

Esempio

// 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)

Rimuove un elemento con un valore specificato.

Sintassi

void remove(value_type val);

Parametri

val
Valore dell'elemento da rimuovere.

Osservazioni:

La funzione membro rimuove un elemento nella sequenza controllata per il quale ((System::Object^)val)->Equals((System::Object^)x) è true (se presente). Viene usato per cancellare un elemento arbitrario con il valore specificato.

Esempio

// 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)

Rimuove gli elementi che superano un test specificato.

Sintassi

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

Parametri

Pred
Verificare la rimozione degli elementi.

Osservazioni:

La funzione membro rimuove dalla sequenza controllata (cancella) ogni elemento X per il quale pred(X) è true. Viene usato per rimuovere tutti gli elementi che soddisfano una condizione specificata come funzione o delegato.

Esempio

// 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)

Indica la fine della sequenza controllata inversa.

Sintassi

reverse_iterator rend();

Osservazioni:

La funzione membro restituisce un iteratore inverso che punta appena oltre l'inizio della sequenza controllata. Di conseguenza, designa l'oggetto end della sequenza inversa. Viene usato per ottenere un iteratore che designa la current fine della sequenza controllata visualizzata in ordine inverso, ma il relativo stato può cambiare se la lunghezza della sequenza controllata cambia.

Esempio

// 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)

Modifica il numero di elementi.

Sintassi

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

Parametri

new_size
Nuove dimensioni della sequenza controllata.

val
Valore dell'elemento di riempimento.

Osservazioni:

Le funzioni membro assicurano che list::size (STL/CLR)() restituisca quindi new_size. Se deve rendere più lunga la sequenza controllata, la prima funzione membro aggiunge elementi con valore value_type(), mentre la seconda funzione membro aggiunge elementi con value val. Per rendere più breve la sequenza controllata, entrambe le funzioni membro cancellano efficacemente l'ultimo elemento list::size (STL/CLR).() -new_size Viene usato per assicurarsi che la sequenza controllata abbia dimensioni new_size, tagliando o riempimento la sequenza controllata corrente.

Esempio

// 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)

Inverte la sequenza controllata.

Sintassi

void reverse();

Osservazioni:

La funzione membro inverte l'ordine di tutti gli elementi nella sequenza controllata. Viene usato per riflettere un elenco di elementi.

Esempio

// 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)

Tipo di un iteratore inverso della sequenza controllata.

Sintassi

typedef T3 reverse_iterator;

Osservazioni:

Il tipo descrive un oggetto di tipo non specificato T3 che può essere utilizzato come iteratore inverso per la sequenza controllata.

Esempio

// 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)

Conta il numero di elementi.

Sintassi

size_type size();

Osservazioni:

La funzione membro restituisce la lunghezza della sequenza controllata. Viene usato per determinare il numero di elementi attualmente presenti nella sequenza controllata. Se è importante sapere se la sequenza ha dimensioni diverse da zero, vedere list::empty (STL/CLR).If all you care about is if the sequence has nonzero size, see list::empty (STL/CLR)().

Esempio

// 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)

Tipo di distanza con segno tra due elementi.

Sintassi

typedef int size_type;

Osservazioni:

Il tipo descrive un numero di elementi non negativi.

Esempio

// 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)

Ordina la sequenza controllata.

Sintassi

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

Parametri

Pred
Operatore di confronto per le coppie di elementi.

Osservazioni:

La prima funzione membro riorganizzerà gli elementi nella sequenza controllata in modo che vengano ordinati per operator< - gli elementi non diminuiscono nel valore mentre si procede attraverso la sequenza. Questa funzione membro viene usata per ordinare la sequenza in ordine crescente.

La seconda funzione membro si comporta come la prima, ad eccezione del fatto che la sequenza è ordinata da pred -- pred(X, Y) è false per qualsiasi elemento che segue l'elemento XY nella sequenza risultante. Viene usato per ordinare la sequenza in un ordine specificato da una funzione predicato o da un delegato.

Entrambe le funzioni eseguono un ordinamento stabile: nessuna coppia di elementi nella sequenza controllata originale viene invertita nella sequenza controllata risultante.

Esempio

// 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)

Restitch collegamenti tra nodi.

Sintassi

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);

Parametri

first
Inizio dell'intervallo per la giunzione.

last
Fine dell'intervallo per la giunzione.

right
Contenitore da cui eseguire la giunzione.

where
Dove nel contenitore è possibile eseguire la giunzione prima.

Osservazioni:

La prima funzione membro inserisce la sequenza controllata da destra prima dell'elemento nella sequenza controllata a cui punta dove. Rimuove anche tutti gli elementi da destra. (%right non deve essere uguale thisa . È possibile usarlo per complice tutti gli elenchi in un altro.

La seconda funzione membro rimuove l'elemento a cui punta primanella sequenza controllata da destra e lo inserisce prima dell'elemento nella sequenza controllata a cui punta dove. where== ++first==first||whereSe , non viene apportata alcuna modifica. Lo si usa per complice un singolo elemento di un elenco in un altro.

La terza funzione membro inserisce l'intervallo secondario designato da [first, last) dalla sequenza controllata da destra prima dell'elemento nella sequenza controllata a cui punta. Rimuove anche l'intervallo secondario originale dalla sequenza controllata da destra. (Se right == this, l'intervallo [first, last) non deve includere l'elemento a cui punta dove. È possibile usarlo per complicere una sottosequenza di zero o più elementi da un elenco a un altro.

Esempio

// 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)

Scambia il contenuto di due contenitori.

Sintassi

void swap(list<Value>% right);

Parametri

right
Contenitore con cui scambiare il contenuto.

Osservazioni:

La funzione membro scambia le sequenze controllate tra *this e destra. Lo fa in tempo costante e non genera eccezioni. È possibile usarlo come modo rapido per scambiare il contenuto di due contenitori.

Esempio

// 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)

Copia la sequenza controllata in una nuova matrice.

Sintassi

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

Osservazioni:

La funzione membro restituisce una matrice contenente la sequenza controllata. Viene usato per ottenere una copia della sequenza controllata in formato matrice.

Esempio

// 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)

Rimuove gli elementi adiacenti che superano un test specificato.

Sintassi

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

Parametri

Pred
Operatore di confronto per le coppie di elementi.

Osservazioni:

La prima funzione membro rimuove dalla sequenza controllata (cancella) ogni elemento che confronta uguale al relativo elemento precedente: se l'elemento X precede l'elemento Y e X == Y, la funzione membro rimuove Y. Viene usato per rimuovere tutte le copie di ogni sottosequenza di elementi adiacenti che confrontano uguale. Si noti che se la sequenza controllata è ordinata, ad esempio chiamando list::sort (STL/CLR),() la funzione membro lascia solo gli elementi con valori univoci. come indicato dal nome.

La seconda funzione membro si comporta come la prima, ad eccezione del fatto che rimuove ogni elemento dopo un elemento YX per il quale pred(X, Y). È possibile usarlo per rimuovere tutte le copie di ogni sottosequenza di elementi adiacenti che soddisfano una funzione predicato o un delegato specificato. Si noti che se la sequenza controllata è ordinata, ad esempio chiamando sort(pred), la funzione membro lascia solo gli elementi che non dispongono di un ordinamento equivalente con altri elementi.

Esempio

// 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)

Tipo di un elemento.

Sintassi

typedef Value value_type;

Osservazioni:

Il tipo è un sinonimo del parametro di modello Value.

Esempio

// 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)

Confronto non uguale a quello dell'elenco.

Sintassi

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

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione dell'operatore restituisce !(left == right). È possibile usarlo per verificare se left non è ordinato come a destra quando i due elenchi vengono confrontati in base all'elemento.

Esempio

// 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<` (elenco) (STL/CLR)

Elenco minore di confronto.

Sintassi

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

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione dell'operatore restituisce true se, per la posizione i più bassa per la quale !(right[i] < left[i]) è anche true che left[i] < right[i]. In caso contrario, restituisce left->size() < right->size() You use it per verificare se left è ordinato prima di destra quando i due elenchi vengono confrontati elemento per elemento.

Esempio

// 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<=` (elenco) (STL/CLR)

Elencare un confronto minore o uguale.

Sintassi

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

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione dell'operatore restituisce !(right < left). È possibile usarlo per verificare se left non viene ordinato dopo destra quando i due elenchi vengono confrontati in base all'elemento.

Esempio

// 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)

Confronto di uguale elenco.

Sintassi

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

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione operator restituisce true solo se le sequenze controllate da sinistra e destra hanno la stessa lunghezza e, per ogni posizione i, left[i] ==right[i]. È possibile usarlo per verificare se a sinistra viene ordinato lo stesso valore di destra quando i due elenchi vengono confrontati in base all'elemento.

Esempio

// 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>` (elenco) (STL/CLR)

Elenco maggiore del confronto.

Sintassi

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

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione dell'operatore restituisce right<left. Viene usato per verificare se sinistra viene ordinata dopo destra quando i due elenchi vengono confrontati in base all'elemento.

Esempio

// 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>=` (elenco) (STL/CLR)

Elenco maggiore o uguale a confronto.

Sintassi

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

Parametri

left
Contenitore sinistro da confrontare.

right
Contenitore destro da confrontare.

Osservazioni:

La funzione dell'operatore restituisce !(left<right). È possibile usarlo per verificare se left non è ordinato prima di destra quando i due elenchi vengono confrontati in base all'elemento.

Esempio

// 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

Share via

list (STL/CLR)

Sintassi

Parametri

Requisiti

Dichiarazioni

Interfacce

Osservazioni:

Membri

list::assign (STL/CLR)

Sintassi

Parametri

Osservazioni:

Esempio

list::back (STL/CLR)

Sintassi

Osservazioni:

Esempio

list::back_item (STL/CLR)

Sintassi

Osservazioni:

Esempio

list::begin (STL/CLR)

Sintassi

Osservazioni:

Esempio

list::clear (STL/CLR)

Sintassi

Osservazioni:

Esempio

list::const_iterator (STL/CLR)

Sintassi

Osservazioni:

Esempio

list::const_reference (STL/CLR)

Sintassi

Osservazioni:

Esempio

list::const_reverse_iterator (STL/CLR)

Sintassi

Osservazioni:

Esempio

list::difference_type (STL/CLR)

Sintassi

Osservazioni:

Esempio

list::empty (STL/CLR)

Sintassi

Osservazioni:

Esempio

list::end (STL/CLR)

Sintassi

Osservazioni:

Esempio

list::erase (STL/CLR)

Sintassi

Parametri

Osservazioni:

Esempio

list::front (STL/CLR)

Sintassi

Osservazioni:

Esempio

list::front_item (STL/CLR)

Sintassi

Osservazioni:

Esempio

list::generic_container (STL/CLR)

Sintassi

Osservazioni:

Esempio

list::generic_iterator (STL/CLR)

Sintassi

Osservazioni:

Esempio

list::generic_reverse_iterator (STL/CLR)

Sintassi

Osservazioni:

Esempio

list::generic_value (STL/CLR)