list (STL/CLR)

Klasa szablonu opisuje obiekt, który kontroluje różną długość sekwencji elementów, które mają dostęp dwukierunkowy. Kontener służy list do zarządzania sekwencją elementów jako dwukierunkową połączoną listą węzłów, z których każdy przechowuje jeden element.

W poniższym opisie wartość jest taka sama jak Wartość, GValue chyba że ten ostatni jest typem ref, w takim przypadku jest to Value^.

Składnia

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

Parametry

Wartość
Typ elementu w kontrolowanej sekwencji.

Wymagania

Header:<cliext/list>

Przestrzeń nazw: cliext

Deklaracje

Definicja typu	opis
list::const_iterator (STL/CLR)	Typ iteratora stałego dla kontrolowanej sekwencji.
list::const_reference (STL/CLR)	Typ stałego odwołania do elementu.
list::const_reverse_iterator (STL/CLR)	Typ iteratora stałej odwrotnej dla kontrolowanej sekwencji.
list::difference_type (STL/CLR)	Typ odległości ze znakiem między dwoma elementami.
list::generic_container (STL/CLR)	Typ interfejsu ogólnego dla kontenera.
list::generic_iterator (STL/CLR)	Typ iteratora dla interfejsu ogólnego dla kontenera.
list::generic_reverse_iterator (STL/CLR)	Typ iteratora odwrotnego dla interfejsu ogólnego dla kontenera.
list::generic_value (STL/CLR)	Typ elementu dla interfejsu ogólnego kontenera.
list::iterator (STL/CLR)	Typ iteratora dla kontrolowanej sekwencji.
list::reference (STL/CLR)	Typ odwołania do elementu.
list::reverse_iterator (STL/CLR)	Typ iteratora odwrotnego dla kontrolowanej sekwencji.
list::size_type (STL/CLR)	Typ odległości ze znakiem między dwoma elementami.
list::value_type (STL/CLR)	Typ elementu.

Funkcja elementów członkowskich	opis
list::assign (STL/CLR)	Zastępuje wszystkie elementy.
list::back (STL/CLR)	Uzyskuje dostęp do ostatniego elementu.
list::begin (STL/CLR)	Określa początek kontrolowanej sekwencji.
list::clear (STL/CLR)	Usuwa wszystkie elementy.
list::empty (STL/CLR)	Sprawdza, czy nie ma żadnych elementów.
list::end (STL/CLR)	Określa koniec kontrolowanej sekwencji.
list::erase (STL/CLR)	Usuwa elementy z określonych pozycji.
list::front (STL/CLR)	Uzyskuje dostęp do pierwszego elementu.
list::insert (STL/CLR)	Dodaje elementy w określonej pozycji.
list::list (STL/CLR)	Konstruuje obiekt kontenera.
list::merge (STL/CLR)	Scala dwie uporządkowane kontrolowane sekwencje.
list::pop_back (STL/CLR)	Usuwa ostatni element.
list::pop_front (STL/CLR)	Usuwa pierwszy element.
list::push_back (STL/CLR)	Dodaje nowy ostatni element.
list::push_front (STL/CLR)	Dodaje nowy pierwszy element.
list::rbegin (STL/CLR)	Wyznacza początek odwróconej kontrolowanej sekwencji.
list::remove (STL/CLR)	Usuwa element z określoną wartością.
list::remove_if (STL/CLR)	Usuwa elementy, które przechodzą określony test.
list::rend (STL/CLR)	Wyznacza koniec odwróconej kontrolowanej sekwencji.
list::resize (STL/CLR)	Zmienia liczbę elementów.
list::reverse (STL/CLR)	Odwraca kontrolowaną sekwencję.
list::size (STL/CLR)	Liczy liczbę elementów.
list::sort (STL/CLR)	Porządkuje kontrolowaną sekwencję.
list::splice (STL/CLR)	Tworzy łącza między węzłami.
list::swap (STL/CLR)	Zamienia zawartości dwóch kontenerów.
list::to_array (STL/CLR)	Kopiuje kontrolowaną sekwencję do nowej tablicy.
list::unique (STL/CLR)	Usuwa sąsiadujące elementy, które przechodzą określony test.

Właściwości	opis
list::back_item (STL/CLR)	Uzyskuje dostęp do ostatniego elementu.
list::front_item (STL/CLR)	Uzyskuje dostęp do pierwszego elementu.

Operator	opis
list::operator= (STL/CLR)	Zastępuje kontrolowaną sekwencję.
operator!= (list) (STL/CLR)	Określa, czy list obiekt nie jest równy innemu list obiektowi.
operator< (list) (STL/CLR)	Określa, czy list obiekt jest mniejszy niż inny list obiekt.
operator<= (list) (STL/CLR)	Określa, czy list obiekt jest mniejszy lub równy innemu list obiektowi.
operator== (list) (STL/CLR)	Określa, czy list obiekt jest równy innemu list obiektowi.
operator> (list) (STL/CLR)	Określa, czy list obiekt jest większy niż inny list obiekt.
operator>= (list) (STL/CLR)	Określa, czy list obiekt jest większy lub równy innemu list obiektowi.

Interfejsy

Interfejs	opis
ICloneable	Duplikuj obiekt.
IEnumerable	Sekwencja elementów.
ICollection	Zachowaj grupę elementów.
IEnumerable<T>	Sekwencjonowanie przez wpisane elementy.
ICollection<T>	Zachowaj grupę wpisanych elementów.
Wartość IList<>	Obsługa ogólnego kontenera.

Uwagi

Obiekt przydziela i zwalnia magazyn dla sekwencji, która kontroluje jako poszczególne węzły na liście linków dwukierunkowych. Zmienia kolejność elementów, zmieniając łącza między węzłami, nigdy nie kopiując zawartości jednego węzła na inny. Oznacza to, że można swobodnie wstawiać i usuwać elementy bez zakłócania pozostałych elementów. W związku z tym lista jest dobrym kandydatem dla bazowego kontenera dla kolejki klas szablonu (STL/CLR) lub stosu klas szablonu (STL/CLR).

list Obiekt obsługuje iteratory dwukierunkowe, co oznacza, że można przejść do sąsiednich elementów, biorąc pod uwagę iterator, który wyznacza element w kontrolowanej sekwencji. Specjalny węzeł główny odpowiada iteratorowi zwróconego przez list::end (STL/CLR)(). Można dekrementować ten iterator, aby uzyskać dostęp do ostatniego elementu w kontrolowanej sekwencji, jeśli istnieje. Można zwiększać iterator listy, aby uzyskać dostęp do węzła głównego, a następnie porównać wartość równą end(). Nie można jednak wyłusić iteratora zwróconego przez end()element .

Należy pamiętać, że nie można odwołać się bezpośrednio do elementu listy, który wymaga iteratora z dostępem losowym. Dlatego lista nie może być użyteczna jako podstawowy kontener dla klasy szablonu priority_queue (STL/CLR).

Iterator listy przechowuje dojście do skojarzonego węzła listy, który z kolei przechowuje dojście do skojarzonego kontenera. Iteratory można używać tylko ze skojarzonymi obiektami kontenera. Iterator listy pozostaje prawidłowy tak długo, jak skojarzony z nim węzeł listy jest skojarzony z niektórymi listami. Ponadto prawidłowy iterator jest wyłuskiwalny — można go użyć do uzyskania dostępu do lub zmiany wartości elementu, którą wyznaczy — tak długo, jak nie jest równa end().

Wymazywanie lub usuwanie elementu wywołuje destruktor dla jego przechowywanej wartości. Zniszczenie kontenera spowoduje usunięcie wszystkich elementów. W związku z tym kontener, którego typ elementu jest klasą ref, gwarantuje, że żadne elementy nie przeżyją kontenera. Należy jednak pamiętać, że kontener uchwytów nie niszczy jego elementów.

Członkowie

list::assign (STL/CLR)

Zastępuje wszystkie elementy.

Składnia

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

Parametry

count
Liczba elementów do wstawienia.

Pierwszym
Początek zakresu do wstawienia.

Ostatnio
Koniec zakresu do wstawienia.

Prawo
Wyliczenie do wstawienia.

Val
Wartość elementu do wstawienia.

Uwagi

Pierwsza funkcja składowa zastępuje kontrolowaną sekwencję powtórzeniem elementów zliczanych wartości. Służy do wypełniania kontenera elementami o tej samej wartości.

Jeśli InIt jest typem całkowitym, druga funkcja składowa zachowuje się tak samo jak assign((size_type)first, (value_type)last). W przeciwnym razie zastępuje kontrolowaną sekwencję sekwencją [first, last). Służy do tworzenia kontrolowanej sekwencji kopii innej sekwencji.

Trzecia funkcja składowa zastępuje kontrolowaną sekwencję sekwencją wyznaczoną przez prawo modułu wyliczającego. Służy do tworzenia kontrolowanej sekwencji kopii sekwencji opisanej przez moduł wyliczający.

Przykład

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

Uzyskuje dostęp do ostatniego elementu.

Składnia

reference back();

Uwagi

Funkcja składowa zwraca odwołanie do ostatniego elementu kontrolowanej sekwencji, który musi być niepusty. Służy do uzyskiwania dostępu do ostatniego elementu, gdy wiadomo, że istnieje.

Przykład

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

Uzyskuje dostęp do ostatniego elementu.

Składnia

property value_type back_item;

Uwagi

Właściwość uzyskuje dostęp do ostatniego elementu kontrolowanej sekwencji, który musi być niepusty. Służy do odczytywania lub zapisywania ostatniego elementu, gdy wiadomo, że istnieje.

Przykład

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

Określa początek kontrolowanej sekwencji.

Składnia

iterator begin();

Uwagi

Funkcja składowa zwraca iterator dostępu losowego, który wyznacza pierwszy element kontrolowanej sekwencji lub tuż poza końcem pustej sekwencji. Służy do uzyskania iteratora, który wyznacza current początek kontrolowanej sekwencji, ale jego stan może ulec zmianie, jeśli długość kontrolowanej sekwencji ulegnie zmianie.

Przykład

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

Usuwa wszystkie elementy.

Składnia

void clear();

Uwagi

Funkcja składowa skutecznie wywołuje metodę list::erase (STL/CLR)list::begin (STL/CLR)((),list::end (STL/CLR).()) Służy do zapewnienia, że kontrolowana sekwencja jest pusta.

Przykład

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

Typ iteratora stałego dla kontrolowanej sekwencji.

Składnia

typedef T2 const_iterator;

Uwagi

Typ opisuje obiekt nieokreślonego typu T2 , który może służyć jako stały iterator dostępu losowego dla kontrolowanej sekwencji.

Przykład

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

Typ stałego odwołania do elementu.

Składnia

typedef value_type% const_reference;

Uwagi

Typ opisuje stałe odwołanie do elementu.

Przykład

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

Typ iteratora stałej odwrotnej dla kontrolowanej sekwencji.

Składnia

typedef T4 const_reverse_iterator;

Uwagi

Typ opisuje obiekt nieokreślonego typu T4 , który może służyć jako stały iterator odwrotny dla kontrolowanej sekwencji.

Przykład

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

Typy podpisanej odległości między dwoma elementami.

Składnia

typedef int difference_type;

Uwagi

Typ opisuje liczbę podpisanych elementów.

Przykład

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

Sprawdza, czy nie ma żadnych elementów.

Składnia

bool empty();

Uwagi

Funkcja składowa zwraca wartość true dla pustej kontrolowanej sekwencji. Jest ona równoważna list::size (STL/CLR)() == 0. Służy do testowania, czy lista jest pusta.

Przykład

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

Określa koniec kontrolowanej sekwencji.

Składnia

iterator end();

Uwagi

Funkcja składowa zwraca iterator dostępu losowego, który wskazuje tuż poza końcem kontrolowanej sekwencji. Służy do uzyskania iteratora, który wyznacza koniec kontrolowanej sekwencji; jego stan nie zmienia się, jeśli długość kontrolowanej sekwencji ulegnie zmianie.

Przykład

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

Usuwa elementy z określonych pozycji.

Składnia

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

Parametry

Pierwszym
Początek zakresu do wymazywania.

Ostatnio
Koniec zakresu do wymazywania.

Gdzie
Element do wymazywania.

Uwagi

Pierwsza funkcja składowa usuwa element kontrolowanej sekwencji wskazywanej przez miejsce. Służy do usuwania pojedynczego elementu.

Druga funkcja składowa usuwa elementy kontrolowanej sekwencji w zakresie [first, last). Służy do usuwania zera lub większej liczby ciągłych elementów.

Obie funkcje składowe zwracają iterator, który wyznacza pierwszy element pozostały poza usuniętymi elementami lub list::end (STL/CLR),() jeśli taki element nie istnieje.

Podczas wymazywania elementów liczba kopii elementów jest liniowa w liczbie elementów między końcem wymazywania a bliższym końcem sekwencji. (W przypadku wymazywania jednego lub większej liczby elementów na końcu sekwencji nie ma kopii elementów).

Przykład

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

Uzyskuje dostęp do pierwszego elementu.

Składnia

reference front();

Uwagi

Funkcja składowa zwraca odwołanie do pierwszego elementu kontrolowanej sekwencji, który musi być niepusty. Służy do odczytywania lub zapisywania pierwszego elementu, gdy wiadomo, że istnieje.

Przykład

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

Uzyskuje dostęp do pierwszego elementu.

Składnia

property value_type front_item;

Uwagi

Właściwość uzyskuje dostęp do pierwszego elementu kontrolowanej sekwencji, który musi być niepusty. Służy do odczytywania lub zapisywania pierwszego elementu, gdy wiadomo, że istnieje.

Przykład

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

Typ interfejsu ogólnego dla kontenera.

Składnia

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

Uwagi

Typ opisuje ogólny interfejs dla tej klasy kontenera szablonu.

Przykład

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

Typ iteratora do użycia z interfejsem ogólnym kontenera.

Składnia

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

Uwagi

Typ opisuje iterator ogólny, który może być używany z interfejsem ogólnym dla tej klasy kontenera szablonu.

Przykład

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

Typ iteratora odwrotnego do użycia z interfejsem ogólnym kontenera.

Składnia

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

Uwagi

Typ opisuje ogólny iterator odwrotny, który może być używany z interfejsem ogólnym dla tej klasy kontenera szablonu.

Przykład

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

Typ elementu do użycia z interfejsem ogólnym kontenera.

Składnia

typedef GValue generic_value;

Uwagi

Typ opisuje obiekt typu GValue , który opisuje przechowywaną wartość elementu do użycia z interfejsem ogólnym dla tej klasy kontenera szablonu.

Przykład

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

Dodaje elementy w określonej pozycji.

Składnia

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

Parametry

count
Liczba elementów do wstawienia.

Pierwszym
Początek zakresu do wstawienia.

Ostatnio
Koniec zakresu do wstawienia.

Prawo
Wyliczenie do wstawienia.

Val
Wartość elementu do wstawienia.

Gdzie
Gdzie w kontenerze do wstawienia przed.

Uwagi

Każda z funkcji składowych wstawia element przed elementem wskazującym , gdzie w kontrolowanej sekwencji, sekwencja określona przez pozostałe operandy.

Pierwsza funkcja składowa wstawia element z wartością val i zwraca iterator, który wyznacza nowo wstawiony element. Służy do wstawiania pojedynczego elementu przed miejscem wyznaczonym przez iterator.

Druga funkcja składowa wstawia powtórzenie elementów zliczania wartości. Służy do wstawiania zera lub większej liczby ciągłych elementów, które są wszystkimi kopiami tej samej wartości.

Jeśli InIt jest typem całkowitym, trzecia funkcja składowa zachowuje się tak samo jak insert(where, (size_type)first, (value_type)last). W przeciwnym razie wstawia sekwencję [first, last). Służy do wstawiania zera lub większej liczby ciągłych elementów skopiowanych z innej sekwencji.

Czwarta funkcja składowa wstawia sekwencję wyznaczoną po prawej stronie. Służy do wstawiania sekwencji opisanej przez moduł wyliczający.

Podczas wstawiania pojedynczego elementu liczba kopii elementów jest liniowa w liczbie elementów między punktem wstawiania a bliższym końcem sekwencji. (Podczas wstawiania co najmniej jednego elementu na końcu sekwencji nie ma kopii elementów). Jeśli InIt jest iteratorem wejściowym, trzecia funkcja składowa skutecznie wykonuje pojedynczą wstawienie dla każdego elementu w sekwencji. W przeciwnym razie podczas wstawiania N elementów liczba kopii elementów jest liniowa N i liczba elementów między punktem wstawiania a bliższym końcem sekwencji.

Przykład

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

Typ iteratora dla kontrolowanej sekwencji.

Składnia

typedef T1 iterator;

Uwagi

Typ opisuje obiekt nieokreślonego typu T1 , który może służyć jako iterator dostępu losowego dla kontrolowanej sekwencji.

Przykład

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

Konstruuje obiekt kontenera.

Składnia

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

Parametry

count
Liczba elementów do wstawienia.

Pierwszym
Początek zakresu do wstawienia.

Ostatnio
Koniec zakresu do wstawienia.

Prawo
Obiekt lub zakres do wstawienia.

Val
Wartość elementu do wstawienia.

Uwagi

Konstruktor:

list();

inicjuje kontrolowaną sekwencję bez elementów. Służy do określania pustej początkowej kontrolowanej sekwencji.

Konstruktor:

list(list<Value>% right);

inicjuje kontrolowaną sekwencję za pomocą sekwencji [right.begin(), right.end()). Służy do określania początkowej kontrolowanej sekwencji, która jest kopią sekwencji kontrolowanej przez obiekt listy po prawej stronie.

Konstruktor:

list(list<Value>^ right);

inicjuje kontrolowaną sekwencję za pomocą sekwencji [right->begin(), right->end()). Służy do określania początkowej kontrolowanej sekwencji, która jest kopią sekwencji kontrolowanej przez obiekt listy, którego uchwyt jest właściwy.

Konstruktor:

explicit list(size_type count);

inicjuje kontrolowaną sekwencję z elementami zliczanymi z wartością value_type(). Służy do wypełniania kontenera elementami, które mają wartość domyślną.

Konstruktor:

list(size_type count, value_type val);

inicjuje kontrolowaną sekwencję z elementami zliczanymi z każdą wartością. Służy do wypełniania kontenera elementami o tej samej wartości.

Konstruktor:

template<typename InIt>

list(InIt first, InIt last);

inicjuje kontrolowaną sekwencję za pomocą sekwencji [first, last). Służy do tworzenia kontrolowanej sekwencji kopii innej sekwencji.

Konstruktor:

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

inicjuje kontrolowaną sekwencję z sekwencją wyznaczoną przez prawo modułu wyliczającego. Służy do tworzenia kontrolowanej sekwencji kopii innej sekwencji opisanej przez moduł wyliczający.

Przykład

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

Scala dwie uporządkowane kontrolowane sekwencje.

Składnia

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

Parametry

pred
Porównanie par elementów.

Prawo
Kontener do scalenia.

Uwagi

Pierwsza funkcja składowa usuwa wszystkie elementy z sekwencji kontrolowanej przez prawo i wstawia je w kontrolowanej sekwencji. Obie sekwencje muszą być wcześniej uporządkowane według operator< elementów — elementy nie mogą zmniejszać wartości podczas przechodzenia przez jedną sekwencję. Wynikowa sekwencja jest również uporządkowana według operator<. Ta funkcja składowa służy do scalania dwóch sekwencji, które zwiększają wartość w sekwencji, która również zwiększa wartość.

Druga funkcja składowa zachowuje się tak samo jak pierwsza, z tą różnicą, że sekwencje są uporządkowane według pred -- pred(X, Y) musi być fałszem dla każdego elementu X , który następuje po elemencie Y w sekwencji. Służy do scalania dwóch sekwencji uporządkowanych za pomocą określonej funkcji predykatu lub delegata.

Obie funkcje wykonują stabilne scalanie — żadna para elementów w żadnej z oryginalnych kontrolowanych sekwencji jest odwracana w wynikowej kontrolowanej sekwencji. Ponadto jeśli para elementów X i Y w wynikowej kontrolowanej sekwencji ma równoważną kolejność - !(X < Y) && !(X < Y) - element z oryginalnej kontrolowanej sekwencji pojawia się przed elementem z sekwencji kontrolowanej przez prawo.

Przykład

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

Zastępuje kontrolowaną sekwencję.

Składnia

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

Parametry

Prawo
Kontener do skopiowania.

Uwagi

Operator elementu członkowskiego kopiuje prawo do obiektu, a następnie zwraca wartość *this. Służy do zastępowania kontrolowanej sekwencji kopią kontrolowanej sekwencji po prawej stronie.

Przykład

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

Usuwa ostatni element.

Składnia

void pop_back();

Uwagi

Funkcja składowa usuwa ostatni element kontrolowanej sekwencji, który musi być niepusty. Służy do skrócenia listy według jednego elementu z tyłu.

Przykład

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

Usuwa pierwszy element.

Składnia

void pop_front();

Uwagi

Funkcja składowa usuwa pierwszy element kontrolowanej sekwencji, który musi być niepusty. Służy do skrócenia listy według jednego elementu z przodu.

Przykład

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

Dodaje nowy ostatni element.

Składnia

void push_back(value_type val);

Uwagi

Funkcja składowa wstawia element z wartością val na końcu kontrolowanej sekwencji. Służy do dołączania innego elementu do listy.

Przykład

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

Dodaje nowy pierwszy element.

Składnia

void push_front(value_type val);

Uwagi

Funkcja składowa wstawia element z wartością val na początku kontrolowanej sekwencji. Służy do poprzedzania innego elementu do listy.

Przykład

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

Wyznacza początek odwróconej kontrolowanej sekwencji.

Składnia

reverse_iterator rbegin();

Uwagi

Funkcja składowa zwraca iterator odwrotny, który wyznacza ostatni element kontrolowanej sekwencji lub tuż poza początkiem pustej sekwencji. W związku z tym wyznacza beginning sekwencję odwrotną. Służy do uzyskania iteratora, który wyznacza current początek kontrolowanej sekwencji widocznej w odwrotnej kolejności, ale jego stan może ulec zmianie, jeśli długość kontrolowanej sekwencji ulegnie zmianie.

Przykład

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

Typ odwołania do elementu.

Składnia

typedef value_type% reference;

Uwagi

Typ opisuje odwołanie do elementu.

Przykład

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

Usuwa element z określoną wartością.

Składnia

void remove(value_type val);

Parametry

Val
Wartość elementu do usunięcia.

Uwagi

Funkcja składowa usuwa element w kontrolowanej sekwencji, dla której ((System::Object^)val)->Equals((System::Object^)x) wartość true (jeśli istnieje). Służy do wymazywania dowolnego elementu z określoną wartością.

Przykład

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

Usuwa elementy, które przechodzą określony test.

Składnia

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

Parametry

pred
Przetestuj elementy do usunięcia.

Uwagi

Funkcja składowa usuwa z kontrolowanej sekwencji (wymazuje) każdy element X , dla którego pred(X) ma wartość true. Służy do usuwania wszystkich elementów spełniających warunek określony jako funkcja lub delegat.

Przykład

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

Wyznacza koniec odwróconej kontrolowanej sekwencji.

Składnia

reverse_iterator rend();

Uwagi

Funkcja składowa zwraca iterator odwrotny, który wskazuje tuż poza początkiem kontrolowanej sekwencji. W związku z tym wyznacza end sekwencję odwrotną. Służy do uzyskania iteratora, który wyznacza current koniec kontrolowanej sekwencji widocznej w odwrotnej kolejności, ale jego stan może ulec zmianie, jeśli długość kontrolowanej sekwencji ulegnie zmianie.

Przykład

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

Zmienia liczbę elementów.

Składnia

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

Parametry

new_size
Nowy rozmiar kontrolowanej sekwencji.

Val
Wartość elementu dopełniania.

Uwagi

Funkcje składowe zapewniają, że funkcja list::size (STL/CLR)() zwraca new_size. Jeśli musi ona wydłużyć kontrolowaną sekwencję, pierwsza funkcja składowa dołącza elementy z wartością , podczas gdy druga funkcja składowa dołącza elementy z wartością value_type()val. Aby skrócić kontrolowaną sekwencję, oba funkcje składowe skutecznie usuwają ostatni czas list::size (STL/CLR).() -new_size Służy do zapewnienia, że kontrolowana sekwencja ma rozmiar new_size, przycinając lub dopełniając bieżącą kontrolowaną sekwencję.

Przykład

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

Odwraca kontrolowaną sekwencję.

Składnia

void reverse();

Uwagi

Funkcja składowa odwraca kolejność wszystkich elementów w kontrolowanej sekwencji. Służy do odzwierciedlenia listy elementów.

Przykład

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

Typ iteratora odwrotnego dla kontrolowanej sekwencji.

Składnia

typedef T3 reverse_iterator;

Uwagi

Typ opisuje obiekt nieokreślonego typu T3 , który może służyć jako iterator odwrotny dla kontrolowanej sekwencji.

Przykład

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

Liczy liczbę elementów.

Składnia

size_type size();

Uwagi

Funkcja składowa zwraca długość kontrolowanej sekwencji. Służy do określania liczby elementów aktualnie w kontrolowanej sekwencji. Jeśli chodzi o to, czy sekwencja ma rozmiar niezerowy, zobacz list::empty (STL/CLR)().

Przykład

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

Typ podpisanej odległości między dwoma elementami.

Składnia

typedef int size_type;

Uwagi

Typ opisuje nieujemną liczbę elementów.

Przykład

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

Porządkuje kontrolowaną sekwencję.

Składnia

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

Parametry

pred
Porównanie par elementów.

Uwagi

Pierwsza funkcja składowa zmienia kolejność elementów w kontrolowanej sekwencji, tak aby były uporządkowane według operator< - elementy nie zmniejszają wartości podczas przechodzenia przez sekwencję. Ta funkcja składowa służy do sortowania sekwencji w kolejności rosnącej.

Druga funkcja składowa zachowuje się tak samo jak pierwsza, z tą różnicą, że sekwencja jest uporządkowana przez pred -- pred(X, Y) wartość false dla każdego elementu X , który następuje po elemencie Y w wynikowej sekwencji. Służy do sortowania sekwencji w kolejności określonej przez funkcję predykatu lub delegata.

Obie funkcje wykonują stabilny sortowanie — żadna para elementów w oryginalnej kontrolowanej sekwencji nie jest odwracana w wynikowej kontrolowanej sekwencji.

Przykład

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

Łącza restitch między węzłami.

Składnia

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

Parametry

Pierwszym
Początek zakresu do splice.

Ostatnio
Koniec zakresu do splice.

Prawo
Kontener do splice z.

Gdzie
Gdzie w kontenerze do splice wcześniej.

Uwagi

Pierwsza funkcja składowa wstawia sekwencję kontrolowaną bezpośrednioprzed elementem w kontrolowanej sekwencji wskazywanej przez miejsce. Usuwa również wszystkie elementy z prawej strony. (%right nie może być równe this.) Służy do łączenia całej jednej listy z inną.

Druga funkcja składowa usuwa element wskazywany przez pierwszy w sekwencji kontrolowanej przez prawo i wstawia go przed elementem w kontrolowanej sekwencji wskazywanej przez miejsce. (Jeśli where== ++first==first||wherenie nastąpi żadna zmiana). Służy do łączenia pojedynczego elementu jednej listy z inną.

Trzecia funkcja składowa wstawia podrange wyznaczone przez [first, last) z sekwencji kontrolowanej bezpośrednio przed elementem w kontrolowanej sekwencji wskazywanej przez miejsce. Usuwa również oryginalne rozmieszczenie z sekwencji kontrolowanej przez prawo. (Jeśli right == thiszakres [first, last) nie może zawierać elementu wskazywanego przez where. Służy do łączenia podsekwencji z zera lub większej liczby elementów z jednej listy do innej.

Przykład

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

Zamienia zawartości dwóch kontenerów.

Składnia

void swap(list<Value>% right);

Parametry

Prawo
Kontener do zamiany zawartości na.

Uwagi

Funkcja składowa zamienia kontrolowane sekwencje między *this i po prawej stronie. Robi to w stałym czasie i nie zgłasza żadnych wyjątków. Służy ona jako szybki sposób wymiany zawartości dwóch kontenerów.

Przykład

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

Kopiuje kontrolowaną sekwencję do nowej tablicy.

Składnia

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

Uwagi

Funkcja składowa zwraca tablicę zawierającą kontrolowaną sekwencję. Służy do uzyskiwania kopii kontrolowanej sekwencji w postaci tablicy.

Przykład

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

Usuwa sąsiadujące elementy, które przechodzą określony test.

Składnia

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

Parametry

pred
Porównanie par elementów.

Uwagi

Pierwsza funkcja składowa usuwa z kontrolowanej sekwencji (wymazuje) każdy element, który porównuje się z poprzednim elementem - jeśli element X poprzedza element Y i X == Y, funkcja składowa usuwa Yelement . Służy do usuwania wszystkich, ale jednej kopii każdego podsekwencjonowania sąsiednich elementów, które porównują równe. Należy pamiętać, że jeśli sekwencja kontrolowana jest uporządkowana, na przykład przez wywołanie metody list::sort (STL/CLR),() funkcja składowa pozostawia tylko elementy z unikatowymi wartościami. (Stąd nazwa).

Druga funkcja składowa zachowuje się tak samo jak pierwsza, z tą różnicą, że usuwa każdy element Y po elemencie X , dla którego pred(X, Y). Służy do usuwania wszystkich, ale jednej kopii każdej podsekwencji sąsiednich elementów, które spełniają predykat funkcji lub delegata określonego przez Ciebie. Należy pamiętać, że jeśli sekwencja kontrolowana jest uporządkowana, na przykład przez wywołanie sort(pred), funkcja składowa pozostawia tylko elementy, które nie mają równoważnej kolejności z żadnymi innymi elementami.

Przykład

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

Typ elementu.

Składnia

typedef Value value_type;

Uwagi

Typ jest synonimem wartości parametru szablonu.

Przykład

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

Lista nie jest równa porównania.

Składnia

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

Parametry

Lewej
Pozostaw kontener do porównania.

Prawo
Odpowiedni kontener do porównania.

Uwagi

Funkcja operatora zwraca !(left == right)wartość . Służy do testowania, czy lewo nie jest uporządkowane tak samo jak w prawo , gdy dwie listy są porównywane element według elementu.

Przykład

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

Wyświetl listę mniejszą niż porównanie.

Składnia

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

Parametry

Lewej
Pozostaw kontener do porównania.

Prawo
Odpowiedni kontener do porównania.

Uwagi

Funkcja operatora zwraca wartość true, jeśli dla najniższej pozycji i , dla której !(right[i] < left[i]) jest również prawdziwe, że left[i] < right[i]. W przeciwnym razie zwraca left->size() < right->size() wartość Użyto go do przetestowania, czy lewo jest uporządkowane przed prawej, gdy obie listy są porównywane element według elementu.

Przykład

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

Wyświetl listę mniejszą niż lub równą porównanie.

Składnia

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

Parametry

Lewej
Pozostaw kontener do porównania.

Prawo
Odpowiedni kontener do porównania.

Uwagi

Funkcja operatora zwraca !(right < left)wartość . Służy do testowania, czy lewo nie jest uporządkowane po prawej stronie, gdy obie listy są porównywane element według elementu.

Przykład

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

Wyświetl równe porównanie.

Składnia

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

Parametry

Lewej
Pozostaw kontener do porównania.

Prawo
Odpowiedni kontener do porównania.

Uwagi

Funkcja operatora zwraca wartość true tylko wtedy, gdy sekwencje kontrolowane przez lewą i prawą mają taką samą długość, a dla każdej pozycji i, left[i] ==right[i]. Służy do testowania, czy lewo jest uporządkowane tak samo jak w prawo , gdy dwie listy są porównywane element według elementu.

Przykład

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

Wyświetl listę większą niż porównanie.

Składnia

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

Parametry

Lewej
Pozostaw kontener do porównania.

Prawo
Odpowiedni kontener do porównania.

Uwagi

Funkcja operatora zwraca right<leftwartość . Służy do testowania, czy lewo jest uporządkowane po prawej stronie , gdy obie listy są porównywane element według elementu.

Przykład

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

Wyświetl więcej niż lub równe porównanie.

Składnia

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

Parametry

Lewej
Pozostaw kontener do porównania.

Prawo
Odpowiedni kontener do porównania.

Uwagi

Funkcja operatora zwraca !(left<right)wartość . Służy do testowania, czy lewo nie jest uporządkowane przed prawej, gdy obie listy są porównywane element według elementu.

Przykład

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