list (STL/CLR)

Die Vorlagenklasse beschreibt ein Objekt, das eine unterschiedliche Sequenz von Elementen mit bidirektionalem Zugriff steuert. Sie verwenden den Container list , um eine Abfolge von Elementen als bidirektionale verknüpfte Liste von Knoten zu verwalten, wobei jedes Element gespeichert wird.

In der nachstehenden Beschreibung entspricht der Wert, es sei denn, GValue letzteres ist ein Bezugstyp, in diesem Fall ist Value^es .

Syntax

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

Parameter

Wert
Der Typ eines Elements in der kontrollierten Sequenz.

Anforderungen

Header:<cliext/list>

Namespace: cliext

Deklarationen

Typendefinition	Beschreibung
list::const_iterator (STL/CLR)	Der Typ eines konstanten Iterators für die gesteuerte Sequenz.
list::const_reference (STL/CLR)	Der Typ eines konstanten Verweises auf ein Element.
list::const_reverse_iterator (STL/CLR)	Der Typ eines konstanten umgekehrten Iterators für die gesteuerte Sequenz.
list::difference_type (STL/CLR)	Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.
list::generic_container (STL/CLR)	Der Typ der generischen Schnittstelle für den Container.
list::generic_iterator (STL/CLR)	Der Typ eines Iterators für die generische Schnittstelle für den Container.
list::generic_reverse_iterator (STL/CLR)	Der Typ eines Reverse iterators für die generische Schnittstelle für den Container.
list::generic_value (STL/CLR)	Der Typ eines Elements für die generische Schnittstelle für den Container.
list::iterator (STL/CLR)	Der Typ eines Iterators für die gesteuerte Sequenz.
list::reference (STL/CLR)	Der Typ eines Verweises auf ein Element.
list::reverse_iterator (STL/CLR)	Der Typ eines umgekehrten Iterators für die gesteuerte Sequenz.
list::size_type (STL/CLR)	Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.
list::value_type (STL/CLR)	Der Typ eines Elements.

Memberfunktion	Beschreibung
list::assign (STL/CLR)	Ersetzt alle Elemente.
list::back (STL/CLR)	Greift auf das letzte Element zu.
list::begin (STL/CLR)	Legt den Anfang der kontrollierten Sequenz fest.
list::clear (STL/CLR)	Entfernt alle Elemente.
list::empty (STL/CLR)	Testet, ob keine Elemente vorhanden sind.
list::end (STL/CLR)	Legt das Ende der kontrollierten Sequenz fest.
list::erase (STL/CLR)	Entfernt Elemente an den angegebenen Positionen.
list::front (STL/CLR)	Greift auf das erste Element zu.
list::insert (STL/CLR)	Fügt Elemente an einer angegebenen Position hinzu.
list::list (STL/CLR)	Erstellt ein container-Objekt.
list::merge (STL/CLR)	Führt zwei sortierte kontrollierte Sequenzen zusammen.
list::pop_back (STL/CLR)	Entfernt das letzte Element.
list::pop_front (STL/CLR)	Entfernt das erste Element.
list::push_back (STL/CLR)	Fügt ein neues letztes Element hinzu.
list::push_front (STL/CLR)	Fügt ein neues erstes Element hinzu.
list::rbegin (STL/CLR)	Legt den Anfang der umgekehrten kontrollierten Sequenz fest.
list::remove (STL/CLR)	Entfernt ein Element mit einem angegebenen Wert.
list::remove_if (STL/CLR)	Entfernt Elemente, die einen angegebenen Test bestehen.
list::rend (STL/CLR)	Legt das Ende der umgekehrten kontrollierten Sequenz fest.
list::resize (STL/CLR)	Ändert die Anzahl der Elemente.
list::reverse (STL/CLR)	Kehrt die kontrollierte Sequenz um.
list::size (STL/CLR)	Ermittelt die Anzahl von Elementen.
list::sort (STL/CLR)	Sortiert die kontrollierte Sequenz.
list::splice (STL/CLR)	Erneuert Links zwischen Knoten.
list::swap (STL/CLR)	Vertauscht den Inhalt von zwei Containern.
list::to_array (STL/CLR)	Kopiert die kontrollierte Sequenz in ein neues Array.
list::unique (STL/CLR)	Entfernt benachbarte Elemente, die einen angegebenen Test bestehen.

Eigenschaft	Beschreibung
list::back_item (STL/CLR)	Greift auf das letzte Element zu.
list::front_item (STL/CLR)	Greift auf das erste Element zu.

Operator	Beschreibung
list::operator= (STL/CLR)	Ersetzt die kontrollierte Sequenz.
operator!= (list) (STL/CLR)	Bestimmt, ob ein Objekt nicht mit einem list anderen list Objekt identisch ist.
Operator< (Liste) (STL/CLR)	Bestimmt, ob ein Objekt kleiner als ein list anderes list Objekt ist.
operator<= (list) (STL/CLR)	Bestimmt, ob ein Objekt kleiner oder gleich einem list anderen list Objekt ist.
operator== (list) (STL/CLR)	Bestimmt, ob ein Objekt mit einem list anderen list Objekt identisch ist.
Operator> (Liste) (STL/CLR)	Bestimmt, ob ein Objekt größer als ein list anderes list Objekt ist.
operator>= (list) (STL/CLR)	Bestimmt, ob ein Objekt größer oder gleich einem list anderen list Objekt ist.

Schnittstellen

Schnittstelle	Beschreibung
ICloneable	Duplizieren Eines Objekts.
IEnumerable	Sequenzieren durch Elemente.
ICollection	Verwalten sie eine Gruppe von Elementen.
IEnumerable<T>	Sequenz durch eingegebene Elemente.
ICollection<T>	Verwalten der Gruppe von typierten Elementen.
IList-Wert<>	Verwalten Sie generischen Container.

Hinweise

Das Objekt reserviert und gibt Speicherplatz für die Sequenz frei, die es als einzelne Knoten in einer bidirektionalen Verknüpfungsliste steuert. Es ordnet Elemente neu an, indem die Verknüpfungen zwischen Knoten geändert werden, niemals durch Kopieren des Inhalts eines Knotens in einen anderen. Das bedeutet, dass Sie Elemente frei einfügen und entfernen können, ohne die verbleibenden Elemente zu stören. Daher ist eine Liste ein guter Kandidat für den zugrunde liegenden Container für Vorlagenklassenwarteschlange (STL/CLR) oder Vorlagenklassenstapel (STL/CLR).

Ein list Objekt unterstützt bidirektionale Iteratoren. Dies bedeutet, dass Sie bei einem Iterator, der ein Element in der gesteuerten Sequenz angibt, zu benachbarten Elementen wechseln können. Ein spezieller Kopfknoten entspricht dem iterator, der von list::end (STL/CLR)() zurückgegeben wird. Sie können diesen Iterator verringern, um das letzte Element in der gesteuerten Sequenz zu erreichen, falls vorhanden. Sie können einen Listen-Iterator erhöhen, um den Kopfknoten zu erreichen, und es wird dann gleich end()verglichen. Sie können jedoch nicht ableiten, von dem der Iterator zurückgegeben wird end().

Beachten Sie, dass Sie nicht direkt auf ein Listenelement verweisen können, das seine numerische Position angibt – die einen Iterator mit wahlfreiem Zugriff erfordert. Daher kann eine Liste nicht als zugrunde liegender Container für Vorlagenklasse priority_queue (STL/CLR) verwendet werden.

Ein Listen-Iterator speichert ein Handle für den zugeordneten Listenknoten, der wiederum ein Handle für den zugehörigen Container speichert. Sie können Iteratoren nur mit den zugehörigen Containerobjekten verwenden. Ein Listen iterator bleibt gültig, solange der zugehörige Listenknoten einer Liste zugeordnet ist. Darüber hinaus ist ein gültiger Iterator ableitend - Sie können ihn verwenden, um auf den von ihr angegebenen Elementwert zuzugreifen oder ihn zu end()ändern – solange er nicht gleich ist.

Beim Löschen oder Entfernen eines Elements wird der Destruktor für den gespeicherten Wert aufgerufen. Durch das Zerstören des Containers werden alle Elemente gelöscht. Daher stellt ein Container, dessen Elementtyp eine Ref-Klasse ist, sicher, dass keine Elemente den Container überleben. Beachten Sie jedoch, dass ein Container mit Ziehpunkten seine Elemente nicht zerstört.

Member

list::assign (STL/CLR)

Ersetzt alle Elemente.

Syntax

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

Parameter

count
Die Anzahl einzufügender Elemente.

first
Anfang des einzufügenden Bereichs.

last
Ende des einzufügenden Bereichs.

right
Einzufügende Aufzählung.

val
Wert des einzufügenden Elements.

Hinweise

Die erste Memberfunktion ersetzt die kontrollierte Sequenz durch eine Wiederholung von Anzahlelementen von Wertwertwert. Sie verwenden ihn, um den Container mit Elementen zu füllen, die denselben Wert aufweisen.

Wenn InIt es sich um einen ganzzahligen Typ handelt, verhält sich die zweite Memberfunktion wie assign((size_type)first, (value_type)last). Andernfalls ersetzt sie die kontrollierte Sequenz durch die Sequenz [first, last). Sie verwenden sie, um die kontrollierte Sequenz zu einer anderen Sequenz zu machen.

Die dritte Memberfunktion ersetzt die gesteuerte Sequenz durch die sequenz, die durch das Enumeratorrecht festgelegt ist. Sie verwenden sie, um die kontrollierte Sequenz zu einer Kopie einer Sequenz zu machen, die von einem Enumerator beschrieben wird.

Beispiel

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

Greift auf das letzte Element zu.

Syntax

reference back();

Hinweise

Die Memberfunktion gibt einen Verweis auf das letzte Element der gesteuerten Sequenz zurück, die nicht leer sein muss. Sie verwenden es, um auf das letzte Element zuzugreifen, wenn Sie wissen, dass es vorhanden ist.

Beispiel

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

Greift auf das letzte Element zu.

Syntax

property value_type back_item;

Hinweise

Die Eigenschaft greift auf das letzte Element der gesteuerten Sequenz zu, die nicht leer sein muss. Sie verwenden es, um das letzte Element zu lesen oder zu schreiben, wenn Sie wissen, dass es vorhanden ist.

Beispiel

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

Legt den Anfang der kontrollierten Sequenz fest.

Syntax

iterator begin();

Hinweise

Die Memberfunktion gibt einen Iterator mit wahlfreiem Zugriff zurück, der das erste Element der kontrollierten Sequenz oder direkt über das Ende einer leeren Sequenz bestimmt. Sie verwenden es, um einen Iterator zu erhalten, der den current Anfang der kontrollierten Sequenz angibt, aber sein Status kann sich ändern, wenn sich die Länge der kontrollierten Sequenz ändert.

Beispiel

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

Entfernt alle Elemente.

Syntax

void clear();

Hinweise

Die Memberfunktion ruft effektiv list::erase (STL/CLR)( list::begin (STL/CLR)(), list::end (STL/CLR)()) auf. Sie verwenden es, um sicherzustellen, dass die kontrollierte Sequenz leer ist.

Beispiel

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

Der Typ eines konstanten Iterators für die gesteuerte Sequenz.

Syntax

typedef T2 const_iterator;

Hinweise

Der Typ beschreibt ein Objekt nicht angegebener Typs T2 , das als konstanter Iterator für den zufälligen Zugriff für die kontrollierte Sequenz dienen kann.

Beispiel

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

Der Typ eines konstanten Verweises auf ein Element.

Syntax

typedef value_type% const_reference;

Hinweise

Der Typ beschreibt einen Konstantenverweis auf ein Element.

Beispiel

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

Der Typ einer Konstantenumkehr iterator für die kontrollierte Sequenz..

Syntax

typedef T4 const_reverse_iterator;

Hinweise

Der Typ beschreibt ein Objekt nicht angegebener Typs T4 , das als konstanten Reverse iterator für die kontrollierte Sequenz dienen kann.

Beispiel

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

Die Typen eines signierten Abstands zwischen zwei Elementen.

Syntax

typedef int difference_type;

Hinweise

Der Typ beschreibt eine signierte Elementanzahl.

Beispiel

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

Testet, ob keine Elemente vorhanden sind.

Syntax

bool empty();

Hinweise

Die Memberfunktion gibt „true“ für eine leere gesteuerte Sequenz zurück. Es entspricht list::size (STL/CLR)() == 0. Sie verwenden sie, um zu testen, ob die Liste leer ist.

Beispiel

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

Legt das Ende der kontrollierten Sequenz fest.

Syntax

iterator end();

Hinweise

Die Memberfunktion gibt einen Iterator mit zufälligem Zugriff zurück, der unmittelbar über das Ende der kontrollierten Sequenz verweist. Sie verwenden es, um einen Iterator zu erhalten, der das Ende der kontrollierten Sequenz angibt; ihr Status ändert sich nicht, wenn sich die Länge der kontrollierten Sequenz ändert.

Beispiel

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

Entfernt Elemente an den angegebenen Positionen.

Syntax

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

Parameter

first
Anfang des zu löschenden Bereichs.

last
Ende des zu löschenden Bereichs.

where
Element, das gelöscht werden soll.

Hinweise

Die erste Memberfunktion entfernt das Element der kontrollierten Sequenz, auf die durch die Stelle verwiesen wird. Sie verwenden es, um ein einzelnes Element zu entfernen.

Die zweite Memberfunktion entfernt die Elemente der gesteuerten Sequenz im Bereich [first, last). Sie verwenden es, um null oder mehr zusammenhängende Elemente zu entfernen.

Beide Memberfunktionen geben einen Iterator zurück, der das erste Element angibt, das über alle entfernten Elemente hinausgeht, oder list::end (STL/CLR),() wenn kein solches Element vorhanden ist.

Beim Löschen von Elementen ist die Anzahl der Elementkopien linear in der Anzahl der Elemente zwischen dem Ende der Löschung und dem näheren Ende der Sequenz. (Beim Löschen eines oder mehrerer Elemente am Ende der Sequenz treten keine Elementkopien auf.)

Beispiel

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

Greift auf das erste Element zu.

Syntax

reference front();

Hinweise

Die Memberfunktion gibt einen Verweis auf das erste Element der kontrollierten Sequenz zurück, die nicht leer sein muss. Sie verwenden es, um das erste Element zu lesen oder zu schreiben, wenn Sie wissen, dass es vorhanden ist.

Beispiel

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

Greift auf das erste Element zu.

Syntax

property value_type front_item;

Hinweise

Die Eigenschaft greift auf das erste Element der gesteuerten Sequenz zu, die nicht leer sein muss. Sie verwenden es, um das erste Element zu lesen oder zu schreiben, wenn Sie wissen, dass es vorhanden ist.

Beispiel

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

Der Typ der generischen Schnittstelle für den Container.

Syntax

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

Hinweise

Der Typ beschreibt die generische Schnittstelle für diese Vorlagencontainerklasse.

Beispiel

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

Der Typ eines Iterators für die Verwendung mit der generischen Schnittstelle für den Container.

Syntax

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

Hinweise

Der Typ beschreibt einen generischen Iterator, der mit der generischen Schnittstelle für diese Vorlagencontainerklasse verwendet werden kann.

Beispiel

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

Der Typ eines Reverse iterators für die Verwendung mit der generischen Schnittstelle für den Container.

Syntax

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

Hinweise

Der Typ beschreibt einen generischen Reverse iterator, der mit der generischen Schnittstelle für diese Vorlagencontainerklasse verwendet werden kann.

Beispiel

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

Der Typ eines Elements für die Verwendung mit der generischen Schnittstelle für den Container.

Syntax

typedef GValue generic_value;

Hinweise

Der Typ beschreibt ein Objekt vom Typ GValue , das den gespeicherten Elementwert für die Verwendung mit der generischen Schnittstelle für diese Vorlagencontainerklasse beschreibt.

Beispiel

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

Fügt Elemente an einer angegebenen Position hinzu.

Syntax

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

Parameter

count
Die Anzahl einzufügender Elemente.

first
Anfang des einzufügenden Bereichs.

last
Ende des einzufügenden Bereichs.

right
Einzufügende Aufzählung.

val
Wert des einzufügenden Elements.

where
Position im Container, der zuvor eingefügt werden soll.

Hinweise

Jede der Memberfunktionen fügt vor dem Element, auf das in der gesteuerten Sequenz verwiesen wird, eine durch die verbleibenden Operanden angegebene Sequenz ein.

Die erste Memberfunktion fügt ein Element mit Wertwert ein und gibt einen Iterator zurück, der das neu eingefügte Element angibt. Sie verwenden es, um ein einzelnes Element vor einer von einem Iterator festgelegten Stelle einzufügen.

Die zweite Memberfunktion fügt eine Wiederholung von Anzahlelementen von Wertwertwert ein. Sie verwenden sie, um null oder mehr zusammenhängende Elemente einzufügen, die alle Kopien desselben Werts sind.

Wenn InIt ein Ganzzahltyp ist, verhält sich die dritte Memberfunktion genau wie insert(where, (size_type)first, (value_type)last). Andernfalls wird die Sequenz [first, last) eingefügt. Sie verwenden sie, um null oder mehr zusammenhängende Elemente einzufügen, die aus einer anderen Sequenz kopiert wurden.

Die vierte Memberfunktion fügt die von der rechten Seite festgelegte Sequenz ein. Sie verwenden sie, um eine von einem Enumerator beschriebene Sequenz einzufügen.

Beim Einfügen eines einzelnen Elements ist die Anzahl der Elementkopien linear in der Anzahl der Elemente zwischen der Einfügemarke und dem näheren Ende der Sequenz. (Beim Einfügen eines oder mehrerer Elemente am Ende der Sequenz treten keine Elementkopien auf.) Wenn InIt es sich um einen Eingabe-Iterator handelt, führt die dritte Memberfunktion effektiv eine einzelne Einfügung für jedes Element in der Sequenz durch. Andernfalls ist N beim Einfügen N von Elementen die Anzahl der Elementkopien linear und die Anzahl der Elemente zwischen der Einfügemarke und dem näheren Ende der Sequenz.

Beispiel

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

Der Typ eines Iterators für die gesteuerte Sequenz.

Syntax

typedef T1 iterator;

Hinweise

Der Typ beschreibt ein Objekt nicht angegebener Typs T1 , das als Zufallszugriffs-Iterator für die kontrollierte Sequenz dienen kann.

Beispiel

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

Erstellt ein container-Objekt.

Syntax

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

Parameter

count
Die Anzahl einzufügender Elemente.

first
Anfang des einzufügenden Bereichs.

last
Ende des einzufügenden Bereichs.

right
Einzufügendes Objekt bzw. einzufügender Bereich.

val
Wert des einzufügenden Elements.

Hinweise

Der Konstruktor:

list();

initialisiert die kontrollierte Sequenz ohne Elemente. Sie verwenden sie, um eine leere anfängliche kontrollierte Sequenz anzugeben.

Der Konstruktor:

list(list<Value>% right);

initialisiert die kontrollierte Sequenz mit der Sequenz [right.begin(), right.end()). Sie verwenden es, um eine anfängliche kontrollierte Sequenz anzugeben, die eine Kopie der Sequenz ist, die vom Listenobjekt rechts gesteuert wird.

Der Konstruktor:

list(list<Value>^ right);

initialisiert die kontrollierte Sequenz mit der Sequenz [right->begin(), right->end()). Sie verwenden es, um eine anfängliche kontrollierte Sequenz anzugeben, die eine Kopie der Sequenz ist, die durch das Listenobjekt gesteuert wird, dessen Handle rechts ist.

Der Konstruktor:

explicit list(size_type count);

initialisiert die kontrollierte Sequenz mit Zählungselementen mit jedem Wert value_type(). Sie verwenden ihn, um den Container mit Elementen zu füllen, die alle den Standardwert aufweisen.

Der Konstruktor:

list(size_type count, value_type val);

initialisiert die kontrollierte Sequenz mit Zählungselementen , die jeweils einen Wertwert aufweisen. Sie verwenden ihn, um den Container mit Elementen zu füllen, die denselben Wert aufweisen.

Der Konstruktor:

template<typename InIt>

list(InIt first, InIt last);

initialisiert die kontrollierte Sequenz mit der Sequenz [first, last). Sie verwenden sie, um die kontrollierte Sequenz zu einer Kopie einer anderen Sequenz zu machen.

Der Konstruktor:

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

initialisiert die kontrollierte Sequenz mit der Sequenz, die vom Enumerator rechts festgelegt ist. Sie verwenden sie, um die kontrollierte Sequenz zu einer Kopie einer anderen Sequenz zu machen, die von einem Enumerator beschrieben wird.

Beispiel

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

Führt zwei sortierte kontrollierte Sequenzen zusammen.

Syntax

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

Parameter

Pred
Comparer für Elementpaare.

right
Container zum Zusammenführen in.

Hinweise

Mit der ersten Memberfunktion werden alle Elemente aus der von rechts gesteuerten Sequenz entfernt und in die kontrollierte Sequenz eingefügt. Beide Sequenzen müssen zuvor nach operator< -- Elemente dürfen nicht kleiner werden, wenn Sie eine der beiden Sequenzen durchlaufen. Die resultierende Sequenz wird auch nach geordnet.operator< Sie verwenden diese Memberfunktion, um zwei Sequenzen zusammenzuführen, die den Wert in eine Sequenz erhöhen, die ebenfalls in den Wert steigt.

Die zweite Memberfunktion verhält sich genauso wie die erste, mit der Ausnahme, dass die Sequenzen nach pred -- pred(X, Y) "false" für jedes Element sein müssen, das dem Element X Y in der Sequenz folgt. Sie verwenden sie zum Zusammenführen von zwei Sequenzen, die von einer von Ihnen angegebenen Prädikatfunktion oder Stellvertretung sortiert sind.

Beide Funktionen führen einen stabilen Zusammenführungsvorgang durch – in der resultierenden kontrollierten Sequenz wird kein Elementpaar in einer der ursprünglichen gesteuerten Sequenzen umgekehrt. Wenn außerdem ein Elementpaar X und Y in der resultierenden gesteuerten Sequenz eine gleichwertige Reihenfolge aufweisen ( - !(X < Y) && !(X < Y) ein Element aus der ursprünglichen gesteuerten Sequenz wird vor einem Element aus der von rechts gesteuerten Sequenz gesteuerten Sequenz angezeigt.

Beispiel

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

Ersetzt die kontrollierte Sequenz.

Syntax

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

Parameter

right
Der zu kopierende Container.

Hinweise

Der Memberoperator kopiert direkt in das Objekt und gibt dann zurück *this. Sie verwenden sie, um die kontrollierte Sequenz durch eine Kopie der gesteuerten Sequenz rechts zu ersetzen.

Beispiel

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

Entfernt das letzte Element.

Syntax

void pop_back();

Hinweise

Die Memberfunktion entfernt das letzte Element der gesteuerten Sequenz, das nicht leer sein muss. Sie verwenden sie, um die Liste um ein Element auf der Rückseite zu kürzen.

Beispiel

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

Entfernt das erste Element.

Syntax

void pop_front();

Hinweise

Die Memberfunktion entfernt das erste Element der gesteuerten Sequenz, das nicht leer sein muss. Sie verwenden es, um die Liste um ein Element an der Vorderseite zu kürzen.

Beispiel

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

Fügt ein neues letztes Element hinzu.

Syntax

void push_back(value_type val);

Hinweise

Die Memberfunktion fügt ein Element mit Dem Wert val am Ende der gesteuerten Sequenz ein. Sie verwenden es, um ein anderes Element an die Liste anzufügen.

Beispiel

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

Fügt ein neues erstes Element hinzu.

Syntax

void push_front(value_type val);

Hinweise

Die Memberfunktion fügt ein Element mit Dem Wert val am Anfang der gesteuerten Sequenz ein. Sie verwenden es, um der Liste ein anderes Element voranzugestellt.

Beispiel

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

Legt den Anfang der umgekehrten kontrollierten Sequenz fest.

Syntax

reverse_iterator rbegin();

Hinweise

Die Memberfunktion gibt einen Umgekehrten Iterator zurück, der das letzte Element der gesteuerten Sequenz oder direkt hinter dem Anfang einer leeren Sequenz angibt. Daher wird die beginning umgekehrte Sequenz festgelegt. Sie verwenden es, um einen Iterator zu erhalten, der den current Anfang der kontrollierten Sequenz angibt, die in umgekehrter Reihenfolge angezeigt wird, aber sein Status kann sich ändern, wenn sich die Länge der kontrollierten Sequenz ändert.

Beispiel

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

Der Typ eines Verweises auf ein Element.

Syntax

typedef value_type% reference;

Hinweise

Der Typ beschreibt einen Verweis auf ein Element.

Beispiel

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

Entfernt ein Element mit einem angegebenen Wert.

Syntax

void remove(value_type val);

Parameter

val
Wert des zu entfernenden Elements.

Hinweise

Die Memberfunktion entfernt ein Element in der kontrollierten Sequenz, für das ((System::Object^)val)->Equals((System::Object^)x) "true" (falls vorhanden) ist. Verwenden Sie es, um ein beliebiges Element mit dem angegebenen Wert zu löschen.

Beispiel

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

Entfernt Elemente, die einen angegebenen Test bestehen.

Syntax

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

Parameter

Pred
Testen Sie, bis Elemente entfernt werden.

Hinweise

Die Memberfunktion entfernt aus der kontrollierten Sequenz (löscht) jedes Element X , für das pred(X) wahr ist. Sie verwenden es, um alle Elemente zu entfernen, die eine Bedingung erfüllen, die Sie als Funktion oder Stellvertretung angeben.

Beispiel

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

Legt das Ende der umgekehrten kontrollierten Sequenz fest.

Syntax

reverse_iterator rend();

Hinweise

Die Memberfunktion gibt einen Umgekehrten Iterator zurück, der unmittelbar über den Anfang der gesteuerten Sequenz verweist. Daher wird die end umgekehrte Sequenz festgelegt. Sie verwenden es, um einen Iterator zu erhalten, der das current Ende der kontrollierten Sequenz angibt, die in umgekehrter Reihenfolge angezeigt wird, aber sein Status kann sich ändern, wenn sich die Länge der kontrollierten Sequenz ändert.

Beispiel

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

Ändert die Anzahl der Elemente.

Syntax

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

Parameter

new_size
Neue Größe der gesteuerten Sequenz.

val
Wert des Abstandselements.

Hinweise

Die Memberfunktionen stellen daher sicher, dass list::size (STL/CLR)() new_size zurückgibt. Wenn die kontrollierte Sequenz länger sein muss, fügt die erste Memberfunktion Elemente mit Wert value_type()an, während die zweite Memberfunktion Elemente mit Wertwert anfüge. Um die kontrollierte Sequenz zu verkürzen, löschen beide Memberfunktionen effektiv die letzten Elementlisten ::size (STL/CLR)-() - new_size Zeiten. Sie verwenden es, um sicherzustellen, dass die kontrollierte Sequenz größe new_size hat, indem Sie entweder die aktuelle kontrollierte Sequenz kürzen oder auffüllen.

Beispiel

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

Kehrt die kontrollierte Sequenz um.

Syntax

void reverse();

Hinweise

Die Memberfunktion kehrt die Reihenfolge aller Elemente in der gesteuerten Sequenz um. Sie verwenden es, um eine Liste von Elementen widerzuspiegeln.

Beispiel

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

Der Typ eines umgekehrten Iterators für die gesteuerte Sequenz.

Syntax

typedef T3 reverse_iterator;

Hinweise

Der Typ beschreibt ein Objekt nicht angegebener Typs T3 , das als Umgekehrter Iterator für die kontrollierte Sequenz dienen kann.

Beispiel

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

Ermittelt die Anzahl von Elementen.

Syntax

size_type size();

Hinweise

Die Memberfunktion gibt die Länge der gesteuerten Sequenz zurück. Sie verwenden es, um die Anzahl der Elemente zu bestimmen, die sich derzeit in der kontrollierten Sequenz befindet. Wenn Sie sich nur darum kümmern, ob die Sequenz eine Nichtzerogröße aufweist, lesen Sie "list::empty (STL/CLR)"().

Beispiel

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

Der Typ eines signierten Abstands zwischen zwei Elementen.

Syntax

typedef int size_type;

Hinweise

Der Typ beschreibt eine nicht negative Elementanzahl.

Beispiel

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

Sortiert die kontrollierte Sequenz.

Syntax

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

Parameter

Pred
Comparer für Elementpaare.

Hinweise

Die erste Memberfunktion ordnet die Elemente in der gesteuerten Sequenz neu an, sodass sie nach operator< -- Elemente werden beim Durchlaufen der Sequenz nicht verkleinert. Sie verwenden diese Memberfunktion, um die Reihenfolge in erhöhter Reihenfolge zu sortieren.

Die zweite Memberfunktion verhält sich genauso wie die erste, mit der Ausnahme, dass die Sequenz nach pred -- pred(X, Y) "false" für jedes Element sortiert ist, das dem Element X Y in der resultierenden Sequenz folgt. Sie verwenden sie, um die Sequenz in einer Reihenfolge zu sortieren, die Sie durch eine Prädikatfunktion oder einen Delegaten angeben.

Beide Funktionen führen eine stabile Sortierung durch – in der resultierenden kontrollierten Sequenz wird kein Elementpaar in der ursprünglichen gesteuerten Sequenz umgekehrt.

Beispiel

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

Verknüpfungen zwischen Knoten ruhen lassen.

Syntax

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

Parameter

first
Anfang des Bereichs zu komplizieren.

last
Ende des Bereichs zum Komplizen.

right
Container, aus dem gepleißen werden soll.

where
Wo in Container, vor dem komplizen.

Hinweise

Die erste Memberfunktion fügt die Sequenz ein, die von rechts vor dem Element in der gesteuerten Sequenz gesteuert wird, auf die an der Stelle verwiesen wird. Außerdem werden alle Elemente von rechts entfernt. (%right darf nicht gleich thissein.) Sie verwenden es, um alle Listen in eine andere zu komplizieren.

Die zweite Memberfunktion entfernt das Element, auf das zuerst in der von rechten Seite gesteuerten Sequenz verwiesen wird, und fügt es vor dem Element in der kontrollierten Sequenz ein, auf die an der Stelle verwiesen wird. (Wenn where == first || where == ++first, keine Änderung erfolgt.) Sie verwenden es, um ein einzelnes Element einer Liste in eine andere zu komplizieren.

Die dritte Memberfunktion fügt den von [first, ) festgelegten Unterbereich aus der Sequenz ein, lastdie von rechts vor dem Element in der kontrollierten Sequenz gesteuert wird, auf die durch die Stelle verwiesen wird. Außerdem wird der ursprüngliche Unterbereich aus der reihenfolge entfernt, die von rechts gesteuert wird. (Wenn right == this, der Bereich [first, last) darf das Element nicht enthalten, auf das durch den Ort verwiesen wird.) Sie verwenden es, um eine Untermenge von Null oder mehr Elementen aus einer Liste in eine andere zu komplizieren.

Beispiel

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

Vertauscht den Inhalt von zwei Containern.

Syntax

void swap(list<Value>% right);

Parameter

right
Container für den Tausch von Inhalten.

Hinweise

Die Memberfunktion wechselt die gesteuerten Sequenzen zwischen *this und rechts. Dies geschieht in konstanter Zeit und löst keine Ausnahmen aus. Sie verwenden es als schnelle Möglichkeit, den Inhalt von zwei Containern auszutauschen.

Beispiel

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

Kopiert die kontrollierte Sequenz in ein neues Array.

Syntax

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

Hinweise

Die Memberfunktion gibt ein Array zurück, das die kontrollierte Sequenz enthält. Sie verwenden es, um eine Kopie der kontrollierten Sequenz in Arrayform abzurufen.

Beispiel

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

Entfernt benachbarte Elemente, die einen angegebenen Test bestehen.

Syntax

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

Parameter

Pred
Comparer für Elementpaare.

Hinweise

Die erste Memberfunktion entfernt aus der kontrollierten Sequenz (löschtY) jedes Element, das gleich dem vorangehenden Element vergleicht - wenn Element dem Element Y X vorangestellt ist und X == Ydie Memberfunktion entfernt wird. Sie verwenden es, um alle, aber eine Kopie jeder Untermenge benachbarter Elemente zu entfernen, die gleich sind. Beachten Sie, dass die Memberfunktion nur Elemente mit eindeutigen Werten belässt, wenn die kontrollierte Sequenz sortiert ist, z. B. durch Aufrufen von list::sort (STL/CLR).() (Sie beenden – englisch: to terminate – die Abfrage, daher der Name.)

Die zweite Memberfunktion verhält sich genauso wie die erste, mit der Ausnahme, dass jedes Element Y nach einem Element entfernt wird, für das pred(X, Y)ein Element X folgt. Sie verwenden es, um alle, aber eine Kopie jeder Untermenge benachbarter Elemente zu entfernen, die eine von Ihnen angegebene Prädikatfunktion oder Stellvertretung erfüllen. Beachten Sie, dass, wenn die kontrollierte Sequenz sortiert ist, z. B. durch Aufrufen sort(pred), nur Elemente, die keine gleichwertige Reihenfolge mit anderen Elementen aufweisen.

Beispiel

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

Der Typ eines Elements.

Syntax

typedef Value value_type;

Hinweise

Der Typ ist ein Synonym für den Vorlagenparameter Value.

Beispiel

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

Liste nicht gleich Vergleich.

Syntax

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

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt zurück !(left == right). Sie verwenden es, um zu testen, ob links nicht mit der rechten Reihenfolge sortiert ist, wenn die beiden Listen elementweise verglichen werden.

Beispiel

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

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

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

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

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

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

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

operator< (Liste) (STL/CLR)

Liste kleiner als vergleich.

Syntax

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

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt true zurück, wenn, für die niedrigste Positioni, für die !(right[i] < left[i]) sie auch wahr ist.left[i] < right[i] Andernfalls gibt left->size() < right->size() sie zurück. Sie verwenden sie, um zu testen, ob links vor rechts sortiert ist, wenn die beiden Listen Element nach Element verglichen werden.

Beispiel

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

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

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

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

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

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

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

operator<= (Liste) (STL/CLR)

Liste kleiner oder gleicher Vergleich.

Syntax

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

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt zurück !(right < left). Sie verwenden es, um zu testen, ob links nach rechts nicht sortiert ist, wenn die beiden Listen elementweise verglichen werden.

Beispiel

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

Vergleich gleich auflisten.

Syntax

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

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt "true" nur zurück, wenn die von links und rechts gesteuerten Sequenzen dieselbe Länge und für jede Position left[i] == right[i]idie gleiche Länge aufweisen. Sie verwenden sie, um zu testen, ob links gleich geordnet ist wie rechts , wenn die beiden Listen Element nach Element verglichen werden.

Beispiel

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

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

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

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

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

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

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

operator> (Liste) (STL/CLR)

Liste größer als vergleich.

Syntax

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

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt zurück right < left. Sie verwenden sie, um zu testen, ob links nach rechts sortiert ist, wenn die beiden Listen elementnach Element verglichen werden.

Beispiel

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

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

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

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

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

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

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

operator>= (Liste) (STL/CLR)

Liste größer oder gleich vergleich.

Syntax

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

Parameter

left
Linker zu vergleichender Container.

right
Rechter zu vergleichender Container.

Hinweise

Die Operatorfunktion gibt zurück !(left < right). Sie verwenden es, um zu testen, ob links nicht vor rechts sortiert ist, wenn die beiden Listen elementweise verglichen werden.

Beispiel

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