lijst (STL/CLR)

Artikel
02/04/2025

In de sjabloonklasse wordt een object beschreven waarmee een wisselende reeks elementen met bidirectionele toegang wordt bestuurd. U gebruikt de container list om een reeks elementen te beheren als een bidirectionele gekoppelde lijst met knooppunten, die elk één element opslaan.

In de onderstaande beschrijving is GValue hetzelfde als waarde, tenzij de laatste een verwijzingstype is, in dat geval Value^.

Syntaxis

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

Parameters

waarde
Het type element in de gecontroleerde reeks.

Eisen

koptekst:<cliext/list>

naamruimte: cliext

Verklaringen

Typedefinitie	Beschrijving
lijst::const_iterator (STL/CLR)	Het type van een constante iterator voor de gecontroleerde reeks.
lijst::const_reference (STL/CLR)	Het type constante verwijzing naar een element.
lijst::const_reverse_iterator (STL/CLR)	Het type van een constante omgekeerde iterator voor de gecontroleerde reeks.
list::d ifference_type (STL/CLR)	Het type ondertekende afstand tussen twee elementen.
lijst::generic_container (STL/CLR)	Het type van de algemene interface voor de container.
lijst::generic_iterator (STL/CLR)	Het type iterator voor de algemene interface voor de container.
lijst::generic_reverse_iterator (STL/CLR)	Het type omgekeerde iterator voor de algemene interface voor de container.
lijst::generic_value (STL/CLR)	Het type element voor de algemene interface voor de container.
lijst::iterator (STL/CLR)	Het type iterator voor de gecontroleerde reeks.
lijst::reference (STL/CLR)	Het type verwijzing naar een element.
lijst::reverse_iterator (STL/CLR)	Het type omgekeerde iterator voor de gecontroleerde reeks.
lijst::size_type (STL/CLR)	Het type ondertekende afstand tussen twee elementen.
lijst::value_type (STL/CLR)	Het type element.

Lid, functie	Beschrijving
lijst::assign (STL/CLR)	Vervangt alle elementen.
lijst::back (STL/CLR)	Hiermee opent u het laatste element.
lijst::begin (STL/CLR)	Geeft het begin van de gecontroleerde reeks aan.
lijst::clear (STL/CLR)	Hiermee verwijdert u alle elementen.
lijst::empty (STL/CLR)	Test of er geen elementen aanwezig zijn.
lijst::end (STL/CLR)	Geeft het einde van de gecontroleerde reeks aan.
lijst::gum (STL/CLR)	Hiermee verwijdert u elementen op opgegeven posities.
lijst::front (STL/CLR)	Hiermee opent u het eerste element.
lijst::insert (STL/CLR)	Voegt elementen toe op een opgegeven positie.
lijst::list (STL/CLR)	Maakt een containerobject.
lijst::merge (STL/CLR)	Hiermee worden twee geordende gecontroleerde reeksen samengevoegd.
lijst::p op_back (STL/CLR)	Hiermee verwijdert u het laatste element.
lijst::p op_front (STL/CLR)	Hiermee verwijdert u het eerste element.
lijst::p ush_back (STL/CLR)	Hiermee voegt u een nieuw laatste element toe.
list::p ush_front (STL/CLR)	Hiermee voegt u een nieuw eerste element toe.
lijst::rbegin (STL/CLR)	Geeft het begin van de omgekeerde gecontroleerde reeks aan.
lijst::remove (STL/CLR)	Hiermee verwijdert u een element met een opgegeven waarde.
lijst::remove_if (STL/CLR)	Hiermee verwijdert u elementen die aan een opgegeven test voldoen.
lijst::rend (STL/CLR)	Hiermee wordt het einde van de omgekeerde gecontroleerde reeks aangeduid.
lijst::resize (STL/CLR)	Hiermee wijzigt u het aantal elementen.
lijst::reverse (STL/CLR)	Hiermee wordt de gecontroleerde volgorde omgekeerd.
lijst::size (STL/CLR)	Telt het aantal elementen.
lijst::sort (STL/CLR)	Hiermee wordt de gecontroleerde volgorde besteld.
lijst::splice (STL/CLR)	Restitches-koppelingen tussen knooppunten.
lijst::wisselen (STL/CLR)	Hiermee wordt de inhoud van twee containers gewisseld.
lijst::to_array (STL/CLR)	Hiermee kopieert u de gecontroleerde reeks naar een nieuwe matrix.
lijst::unique (STL/CLR)	Hiermee verwijdert u aangrenzende elementen die aan een opgegeven test voldoen.

Eigenschap	Beschrijving
lijst::back_item (STL/CLR)	Hiermee opent u het laatste element.
lijst::front_item (STL/CLR)	Hiermee opent u het eerste element.

Bediener	Beschrijving
list::operator= (STL/CLR)	Vervangt de gecontroleerde volgorde.
operator!= (list) (STL/CLR)	Bepaalt of een `list` object niet gelijk is aan een ander `list` object.
operator< (lijst) (STL/CLR)	Bepaalt of een `list` object kleiner is dan een ander `list` object.
operator<= (lijst) (STL/CLR)	Bepaalt of een `list` object kleiner is dan of gelijk is aan een ander `list` object.
operator== (list) (STL/CLR)	Bepaalt of een `list` object gelijk is aan een ander `list`-object.
operator> (lijst) (STL/CLR)	Bepaalt of een `list` object groter is dan een ander `list` object.
operator>= (lijst) (STL/CLR)	Bepaalt of een `list` object groter is dan of gelijk is aan een ander `list` object.

Interfaces

Interface	Beschrijving
ICloneable	Een object dupliceren.
IEnumerable	Sequentieer door elementen.
ICollection	Groep elementen behouden.
IEnumerable<T>	Sequentieer door getypte elementen.
ICollection<T>	Groep getypte elementen onderhouden.
IList<value>	Algemene container onderhouden.

Opmerkingen

Het object wijst opslag toe en maakt opslag vrij voor de volgorde die wordt bestuurd als afzonderlijke knooppunten in een lijst met tweerichtingskoppelingen. Het rangschikt elementen door de koppelingen tussen knooppunten te wijzigen, nooit door de inhoud van het ene knooppunt naar het andere te kopiëren. Dat betekent dat u elementen vrij kunt invoegen en verwijderen zonder dat u de resterende elementen hoeft te storen. Een lijst is dus een goede kandidaat voor de onderliggende container voor sjabloonklasse wachtrij (STL/CLR) of sjabloonklasse stack (STL/CLR).

Een list-object ondersteunt bidirectionele iterators. Dit betekent dat u naar aangrenzende elementen kunt gaan op basis van een iterator die een element in de gecontroleerde volgorde aanwijst. Een speciaal hoofdknooppunt komt overeen met de iterator die wordt geretourneerd door lijst::end (STL/CLR)(). U kunt deze iterator verlagen om het laatste element in de gecontroleerde volgorde te bereiken, indien aanwezig. U kunt een lijst-iterator verhogen om het hoofdknooppunt te bereiken, waarna het gelijk is aan end(). Maar u kunt de iterator die door end()wordt geretourneerd, niet deductie geven.

Houd er rekening mee dat u niet rechtstreeks naar een lijstelement kunt verwijzen op basis van de numerieke positie. Hiervoor is een iterator voor willekeurige toegang vereist. Een lijst is dus niet bruikbaar als de onderliggende container voor sjabloonklasse priority_queue (STL/CLR).

In een lijst-iterator wordt een ingang opgeslagen in het bijbehorende lijstknooppunt, waarin op zijn beurt een ingang wordt opgeslagen in de bijbehorende container. U kunt iterators alleen gebruiken met de bijbehorende containerobjecten. Een lijst-iterator blijft geldig zolang het bijbehorende lijstknooppunt aan een lijst is gekoppeld. Bovendien kan een geldige iterator worden uitgesteld - u kunt deze gebruiken om toegang te krijgen tot of de aan te wijzen elementwaarde te wijzigen - zolang deze niet gelijk is aan end().

Door een element te wissen of te verwijderen, wordt de destructor voor de opgeslagen waarde aanroepen. Als u de container vernietigt, worden alle elementen gewist. Een container waarvan het elementtype een verw-klasse is, zorgt er dus voor dat geen elementen de container overleeft. Houd er echter rekening mee dat een container met ingangen de elementen niet vernietigen.

Leden

list::assign (STL/CLR)

Vervangt alle elementen.

Syntaxis

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

Parameters

aantal
Aantal elementen dat moet worden ingevoegd.

eerste
Begin van het bereik dat moet worden ingevoegd.

laatste
Einde van het bereik dat moet worden ingevoegd.

Opsomming die moet worden ingevoegd.

val-
De waarde van het element dat moet worden ingevoegd.

Opmerkingen

De eerste lidfunctie vervangt de gecontroleerde reeks door een herhaling van aantal elementen van waarde val. U gebruikt deze om de container te vullen met elementen die allemaal dezelfde waarde hebben.

Als InIt een geheel getal is, gedraagt de tweede lidfunctie zich hetzelfde als assign((size_type)first, (value_type)last). Anders wordt de gecontroleerde reeks vervangen door de reeks [first, last). U gebruikt deze om de gecontroleerde reeks een andere reeks te maken.

De derde lidfunctie vervangt de gecontroleerde reeks door de reeks die is aangewezen door de enumerator rechter. U gebruikt deze om de gecontroleerde volgorde een kopie te maken van een reeks die wordt beschreven door een enumerator.

Voorbeeld

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

Hiermee opent u het laatste element.

Syntaxis

reference back();

Opmerkingen

De lidfunctie retourneert een verwijzing naar het laatste element van de gecontroleerde reeks, die niet leeg moet zijn. U gebruikt het om toegang te krijgen tot het laatste element wanneer u weet dat het bestaat.

Voorbeeld

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

Hiermee opent u het laatste element.

Syntaxis

property value_type back_item;

Opmerkingen

De eigenschap heeft toegang tot het laatste element van de gecontroleerde reeks, die niet leeg moet zijn. U gebruikt het om het laatste element te lezen of te schrijven, wanneer u weet dat het bestaat.

Voorbeeld

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

Geeft het begin van de gecontroleerde reeks aan.

Syntaxis

iterator begin();

Opmerkingen

De lidfunctie retourneert een iterator voor willekeurige toegang die het eerste element van de gecontroleerde reeks aanwijst, of net voorbij het einde van een lege reeks. U gebruikt deze om een iterator te verkrijgen die het current begin van de gecontroleerde reeks aanwijst, maar de status ervan kan veranderen als de lengte van de gecontroleerde reeks verandert.

Voorbeeld

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

Hiermee verwijdert u alle elementen.

Syntaxis

void clear();

Opmerkingen

De lidfunctie roept lijst::gum (STL/CLR)(lijst aan::begin (STL/CLR)(),lijst::end (STL/CLR)()). U gebruikt deze om ervoor te zorgen dat de gecontroleerde volgorde leeg is.

Voorbeeld

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

Het type van een constante iterator voor de gecontroleerde reeks.

Syntaxis

typedef T2 const_iterator;

Opmerkingen

Het type beschrijft een object van niet-opgegeven type T2 dat kan fungeren als een constante iterator voor willekeurige toegang voor de gecontroleerde reeks.

Voorbeeld

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

Het type constante verwijzing naar een element.

Syntaxis

typedef value_type% const_reference;

Opmerkingen

Het type beschrijft een constante verwijzing naar een element.

Voorbeeld

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

Het type van een constante omgekeerde iterator voor de gecontroleerde reeks.

Syntaxis

typedef T4 const_reverse_iterator;

Opmerkingen

Het type beschrijft een object van niet-opgegeven type T4 dat kan fungeren als een constante omgekeerde iterator voor de gecontroleerde reeks.

Voorbeeld

// 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::d ifference_type (STL/CLR)

De typen van een ondertekende afstand tussen twee elementen.

Syntaxis

typedef int difference_type;

Opmerkingen

Het type beschrijft het aantal ondertekende elementen.

Voorbeeld

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

Test of er geen elementen aanwezig zijn.

Syntaxis

bool empty();

Opmerkingen

De lidfunctie retourneert waar voor een lege beheerde reeks. Het is gelijk aan lijst::size (STL/CLR)() == 0. U gebruikt deze om te testen of de lijst leeg is.

Voorbeeld

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

lijst::end (STL/CLR)

Geeft het einde van de gecontroleerde reeks aan.

Syntaxis

iterator end();

Opmerkingen

De lidfunctie retourneert een iterator voor willekeurige toegang die net buiten het einde van de gecontroleerde reeks wijst. U gebruikt deze om een iterator te verkrijgen die het einde van de gecontroleerde reeks aanwijst; de status verandert niet als de lengte van de gecontroleerde reeks verandert.

Voorbeeld

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

Hiermee verwijdert u elementen op opgegeven posities.

Syntaxis

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

Parameters

eerste
Begin van bereik om te wissen.

laatste
Einde van bereik dat moet worden gewist.

waar
Element dat moet worden gewist.

Opmerkingen

De eerste lidfunctie verwijdert het element van de gecontroleerde reeks waarnaar wordt verwezen door waar. U gebruikt dit om één element te verwijderen.

De tweede lidfunctie verwijdert de elementen van de gecontroleerde reeks in het bereik [first, last). U gebruikt het om nul of meer aaneengesloten elementen te verwijderen.

Beide lidfuncties retourneren een iterator die het eerste element aanwijst dat buiten alle verwijderde elementen valt of lijst::end (STL/CLR)() als er geen dergelijk element bestaat.

Bij het wissen van elementen is het aantal elementkopieën lineair in het aantal elementen tussen het einde van de verwijdering en het dichtstbijzijnde einde van de reeks. (Bij het wissen van een of meer elementen aan een van beide uiteinden van de reeks, worden er geen elementkopieën weergegeven.)

Voorbeeld

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

Hiermee opent u het eerste element.

Syntaxis

reference front();

Opmerkingen

De lidfunctie retourneert een verwijzing naar het eerste element van de gecontroleerde reeks, die niet leeg moet zijn. U gebruikt het om het eerste element te lezen of te schrijven, wanneer u weet dat het bestaat.

Voorbeeld

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

Hiermee opent u het eerste element.

Syntaxis

property value_type front_item;

Opmerkingen

De eigenschap heeft toegang tot het eerste element van de gecontroleerde reeks, die niet leeg moet zijn. U gebruikt het om het eerste element te lezen of te schrijven, wanneer u weet dat het bestaat.

Voorbeeld

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

Het type van de algemene interface voor de container.

Syntaxis

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

Opmerkingen

Het type beschrijft de algemene interface voor deze sjablooncontainerklasse.

Voorbeeld

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

Het type iterator voor gebruik met de algemene interface voor de container.

Syntaxis

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

Opmerkingen

Het type beschrijft een algemene iterator die kan worden gebruikt met de algemene interface voor deze sjablooncontainerklasse.

Voorbeeld

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

Het type omgekeerde iterator voor gebruik met de algemene interface voor de container.

Syntaxis

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

Opmerkingen

Het type beschrijft een algemene omgekeerde iterator die kan worden gebruikt met de algemene interface voor deze sjablooncontainerklasse.

Voorbeeld

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

Het type element dat moet worden gebruikt met de algemene interface voor de container.

Syntaxis

typedef GValue generic_value;

Opmerkingen

Het type beschrijft een object van het type GValue dat de waarde van het opgeslagen element beschrijft voor gebruik met de algemene interface voor deze sjablooncontainerklasse.

Voorbeeld

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

Voegt elementen toe op een opgegeven positie.

Syntaxis

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

Parameters

aantal
Aantal elementen dat moet worden ingevoegd.

eerste
Begin van het bereik dat moet worden ingevoegd.

laatste
Einde van het bereik dat moet worden ingevoegd.

Opsomming die moet worden ingevoegd.

val-
De waarde van het element dat moet worden ingevoegd.

waar
Waar in de container moet worden ingevoegd.

Opmerkingen

Elk van de lidfuncties wordt ingevoegd, vóór het element waarnaar wordt verwezen door waar in de gecontroleerde volgorde, een reeks die is opgegeven door de resterende operanden.

Met de functie eerste lid wordt een element ingevoegd met de waarde val en wordt een iterator geretourneerd waarmee het zojuist ingevoegde element wordt aangewezen. U gebruikt dit om één element in te voegen voor een plaats die is aangewezen door een iterator.

Met de functie tweede lid wordt een herhaling ingevoegd van aantal elementen van waarde val. U gebruikt deze om nul of meer aaneengesloten elementen in te voegen die allemaal kopieën van dezelfde waarde zijn.

Als InIt een geheel getal is, gedraagt de functie van het derde lid zich hetzelfde als insert(where, (size_type)first, (value_type)last). Anders wordt de reeks [first, last) ingevoegd. U kunt deze gebruiken om nul of meer aaneengesloten elementen in te voegen die zijn gekopieerd uit een andere reeks.

Met de vierde lidfunctie wordt de volgorde ingevoegd die is aangewezen door de rechter. U gebruikt deze om een reeks in te voegen die wordt beschreven door een opsommingsprogramma.

Wanneer u één element invoegt, is het aantal kopieën van elementen lineair in het aantal elementen tussen de invoegpositie en het dichtstbijzijnde einde van de reeks. (Wanneer u een of meer elementen aan een van beide uiteinden van de reeks invoegt, worden er geen elementkopieën weergegeven.) Als InIt een invoer-iterator is, voert de derde lidfunctie effectief één invoeging uit voor elk element in de reeks. Als u N elementen invoegt, is het aantal kopieën van elementen lineair in N plus het aantal elementen tussen de invoegpositie en het dichtstbijzijnde einde van de reeks.

Voorbeeld

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

Het type iterator voor de gecontroleerde reeks.

Syntaxis

typedef T1 iterator;

Opmerkingen

Het type beschrijft een object van niet-opgegeven type T1 dat kan fungeren als een iterator voor willekeurige toegang voor de gecontroleerde reeks.

Voorbeeld

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

Maakt een containerobject.

Syntaxis

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

Parameters

aantal
Aantal elementen dat moet worden ingevoegd.

eerste
Begin van het bereik dat moet worden ingevoegd.

laatste
Einde van het bereik dat moet worden ingevoegd.

Object of bereik dat moet worden ingevoegd.

val-
De waarde van het element dat moet worden ingevoegd.

Opmerkingen

De constructor:

list();

initialiseert de gecontroleerde reeks zonder elementen. U gebruikt deze om een lege initiële gecontroleerde reeks op te geven.

De constructor:

list(list<Value>% right);

initialiseert de gecontroleerde reeks met de reeks [right.begin(), right.end()). U gebruikt deze om een eerste gecontroleerde reeks op te geven die een kopie is van de reeks die wordt beheerd door het lijstobject rechts.

De constructor:

list(list<Value>^ right);

initialiseert de gecontroleerde reeks met de reeks [right->begin(), right->end()). U gebruikt deze om een initiële beheerde reeks op te geven die een kopie is van de reeks die wordt beheerd door het lijstobject waarvan de ingang rechts.

De constructor:

explicit list(size_type count);

initialiseert de gecontroleerde reeks met aantal elementen elk met waarde value_type(). U gebruikt deze om de container te vullen met elementen die allemaal de standaardwaarde hebben.

De constructor:

list(size_type count, value_type val);

initialiseert de gecontroleerde reeks met aantal elementen elk met waarde val. U gebruikt deze om de container te vullen met elementen die allemaal dezelfde waarde hebben.

De constructor:

template<typename InIt>

list(InIt first, InIt last);

initialiseert de gecontroleerde reeks met de reeks [first, last). U gebruikt deze om de gecontroleerde reeks een kopie van een andere reeks te maken.

De constructor:

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

initialiseert de gecontroleerde reeks met de volgorde die is aangewezen door de enumerator rechter. U gebruikt deze om de gecontroleerde reeks een kopie te maken van een andere reeks die wordt beschreven door een enumerator.

Voorbeeld

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

Hiermee worden twee geordende gecontroleerde reeksen samengevoegd.

Syntaxis

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

Parameters

Comparer voor elementparen.

Container die moet worden samengevoegd.

Opmerkingen

De eerste lidfunctie verwijdert alle elementen uit de reeks die wordt beheerd door rechter en voegt deze in de gecontroleerde volgorde in. Beide reeksen moeten eerder worden geordend door operator<- elementen mogen niet afnemen in waarde terwijl u door een van beide reeksen gaat. De resulterende volgorde wordt ook geordend door operator<. U gebruikt deze lidfunctie om twee reeksen samen te voegen die de waarde verhogen in een reeks die ook de waarde verhoogt.

De tweede lidfunctie gedraagt zich hetzelfde als de eerste, behalve dat de reeksen worden gerangschikt door pred -- pred(X, Y) onwaar moeten zijn voor elk element X dat volgt Y in de reeks. U kunt deze gebruiken om twee reeksen samen te voegen die zijn gerangschikt op basis van een predicaatfunctie of gemachtigde die u opgeeft.

Beide functies voeren een stabiele samenvoeging uit. Er worden geen paar elementen in een van de oorspronkelijke gecontroleerde reeksen omgekeerd in de resulterende gecontroleerde reeks. Als een paar elementen X en Y in de resulterende gecontroleerde reeks gelijkwaardige volgorde heeft -- !(X < Y) && !(X < Y) -- wordt een element uit de oorspronkelijke gecontroleerde reeks weergegeven voordat een element uit de reeks die wordt beheerd door rechter.

Voorbeeld

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

Vervangt de gecontroleerde volgorde.

Syntaxis

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

Parameters

Te kopiëren container.

Opmerkingen

De lidoperator kopieert rechter naar het object en retourneert vervolgens *this. U gebruikt deze om de gecontroleerde reeks te vervangen door een kopie van de gecontroleerde reeks in rechter.

Voorbeeld

// 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::p op_back (STL/CLR)

Hiermee verwijdert u het laatste element.

Syntaxis

void pop_back();

Opmerkingen

De lidfunctie verwijdert het laatste element van de gecontroleerde reeks, die niet leeg moet zijn. U kunt deze gebruiken om de lijst met één element aan de achterkant in te korten.

Voorbeeld

// 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::p op_front (STL/CLR)

Hiermee verwijdert u het eerste element.

Syntaxis

void pop_front();

Opmerkingen

De lidfunctie verwijdert het eerste element van de gecontroleerde reeks, die niet leeg moet zijn. U kunt deze gebruiken om de lijst met één element aan de voorzijde te verkorten.

Voorbeeld

// 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::p ush_back (STL/CLR)

Hiermee voegt u een nieuw laatste element toe.

Syntaxis

void push_back(value_type val);

Opmerkingen

Met de lidfunctie wordt een element ingevoegd met waarde val aan het einde van de gecontroleerde reeks. U kunt dit gebruiken om een ander element toe te voegen aan de lijst.

Voorbeeld

// 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::p ush_front (STL/CLR)

Hiermee voegt u een nieuw eerste element toe.

Syntaxis

void push_front(value_type val);

Opmerkingen

Met de lidfunctie wordt een element ingevoegd met waarde val aan het begin van de gecontroleerde reeks. U gebruikt dit om een ander element toe te passen aan de lijst.

Voorbeeld

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

Geeft het begin van de omgekeerde gecontroleerde reeks aan.

Syntaxis

reverse_iterator rbegin();

Opmerkingen

De lidfunctie retourneert een omgekeerde iterator die het laatste element van de gecontroleerde reeks aanwijst, of net voorbij het begin van een lege reeks. Daarom wordt de beginning van de omgekeerde reeks aangewezen. U gebruikt deze om een iterator te verkrijgen die het current begin van de gecontroleerde reeks aanwijst in omgekeerde volgorde, maar de status ervan kan veranderen als de lengte van de gecontroleerde reeks verandert.

Voorbeeld

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

Het type verwijzing naar een element.

Syntaxis

typedef value_type% reference;

Opmerkingen

Het type beschrijft een verwijzing naar een element.

Voorbeeld

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

Hiermee verwijdert u een element met een opgegeven waarde.

Syntaxis

void remove(value_type val);

Parameters

val-
De waarde van het element dat u wilt verwijderen.

Opmerkingen

De lidfunctie verwijdert een element in de gecontroleerde volgorde waarvoor ((System::Object^)val)->Equals((System::Object^)x) waar is (indien van toepassing). U gebruikt dit om een willekeurig element met de opgegeven waarde te wissen.

Voorbeeld

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

Hiermee verwijdert u elementen die aan een opgegeven test voldoen.

Syntaxis

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

Parameters

Test of elementen moeten worden verwijderd.

Opmerkingen

De lidfunctie verwijdert uit de gecontroleerde reeks (wist) elk element X waarvoor pred(X) waar is. U gebruikt dit om alle elementen te verwijderen die voldoen aan een voorwaarde die u opgeeft als functie of gemachtigde.

Voorbeeld

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

Hiermee wordt het einde van de omgekeerde gecontroleerde reeks aangeduid.

Syntaxis

reverse_iterator rend();

Opmerkingen

De lidfunctie retourneert een omgekeerde iterator die net buiten het begin van de gecontroleerde reeks wijst. Daarom wordt de end van de omgekeerde reeks aangewezen. U gebruikt deze om een iterator te verkrijgen die het current einde van de gecontroleerde reeks aanwijst die in omgekeerde volgorde wordt gezien, maar de status ervan kan veranderen als de lengte van de gecontroleerde reeks verandert.

Voorbeeld

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

Hiermee wijzigt u het aantal elementen.

Syntaxis

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

Parameters

new_size
Nieuwe grootte van de gecontroleerde reeks.

val-
Waarde van het opvullingselement.

Opmerkingen

De lidfuncties zorgen ervoor dat lijst::size (STL/CLR)() vanaf nu new_sizeretourneert. Als de gecontroleerde volgorde langer moet worden uitgevoerd, voegt de eerste lidfunctie elementen toe met waarde value_type(), terwijl de tweede lidfunctie elementen met waarde valtoevoegt. Als u de gecontroleerde reeks korter wilt maken, wissen beide lidfuncties het laatste element effectief lijst::size (STL/CLR)() -new_size keer. U gebruikt deze om ervoor te zorgen dat de gecontroleerde reeks de grootte new_sizeheeft, door de huidige gecontroleerde reeks te knippen of op te vullingen.

Voorbeeld

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

Hiermee wordt de gecontroleerde volgorde omgekeerd.

Syntaxis

void reverse();

Opmerkingen

De lidfunctie keert de volgorde van alle elementen in de gecontroleerde volgorde om. U gebruikt deze om een lijst met elementen weer te geven.

Voorbeeld

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

Het type omgekeerde iterator voor de gecontroleerde reeks.

Syntaxis

typedef T3 reverse_iterator;

Opmerkingen

Het type beschrijft een object van niet-opgegeven type T3 dat kan fungeren als een omgekeerde iterator voor de gecontroleerde reeks.

Voorbeeld

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

Telt het aantal elementen.

Syntaxis

size_type size();

Opmerkingen

De lidfunctie retourneert de lengte van de gecontroleerde reeks. U gebruikt deze om het aantal elementen te bepalen dat zich momenteel in de gecontroleerde volgorde bevindt. Als u alleen maar wilt weten of de reeks een niet-nulgrootte heeft, raadpleegt u lijst::empty (STL/CLR)().

Voorbeeld

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

Het type ondertekende afstand tussen twee elementen.

Syntaxis

typedef int size_type;

Opmerkingen

Het type beschrijft een niet-negatief aantal elementen.

Voorbeeld

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

Hiermee wordt de gecontroleerde volgorde besteld.

Syntaxis

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

Parameters

Comparer voor elementparen.

Opmerkingen

De eerste lidfunctie rangschikt de elementen in de gecontroleerde volgorde zodanig dat ze worden gerangschikt door operator<- elementen nemen niet af in waarde wanneer u door de reeks loopt. U gebruikt deze lidfunctie om de volgorde in oplopende volgorde te sorteren.

De tweede lidfunctie gedraagt zich hetzelfde als de eerste, behalve dat de volgorde wordt geordend door pred -- pred(X, Y) onwaar is voor elk element X dat het volgende element Y in de resulterende reeks. U gebruikt deze om de volgorde te sorteren in een volgorde die u opgeeft door een predicaatfunctie of gemachtigde.

Beide functies voeren een stabiele sortering uit: er worden geen paar elementen in de oorspronkelijke gecontroleerde reeks omgekeerd in de resulterende gecontroleerde reeks.

Voorbeeld

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

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

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

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

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

a b c
c b a
a b c

list::splice (STL/CLR)

Restitch-koppelingen tussen knooppunten.

Syntaxis

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

Parameters

eerste
Begin van bereik om te splitsen.

laatste
Einde van bereik om te splitsen.

Container waaruit moet worden geplicerd.

waar
Waar in de container moet worden gepliceerd.

Opmerkingen

Met de eerste lidfunctie wordt de volgorde ingevoegd die wordt bepaald door rechts vóór het element in de gecontroleerde reeks waarnaar wordt verwezen door waar. Ook worden alle elementen uit rechterverwijderd. (%right mag niet gelijk zijn aan this.) U kunt deze gebruiken om alle lijsten te koppelen aan een andere lijst.

De tweede lidfunctie verwijdert het element waarnaar wordt verwezen door eerste in de volgorde die wordt bepaald door rechter en voegt het in voor het element in de gecontroleerde volgorde waarnaar wordt verwezen door waar. (Als where==first||where== ++first, treedt er geen wijziging op.) U kunt deze gebruiken om één element van de ene lijst te koppelen aan een andere.

Met de functie derde lid wordt de door [first, last) aangewezen subbereik ingevoegd uit de reeks die wordt bepaald door rechts vóór het element in de gecontroleerde volgorde waarnaar wordt verwezen door waar. Het verwijdert ook de oorspronkelijke subbereik uit de reeks die wordt beheerd door rechter. (Indien right == thismag het bereik [first, last) niet het element bevatten waarnaar wordt verwezen door waar.) U kunt deze gebruiken om een subsequence van nul of meer elementen uit de ene lijst in een andere te splitsen.

Voorbeeld

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

Hiermee wordt de inhoud van twee containers gewisseld.

Syntaxis

void swap(list<Value>% right);

Parameters

Container waarmee inhoud moet worden gewisseld.

Opmerkingen

De lidfunctie wisselt de gecontroleerde reeksen tussen *this en rechter. Dit gebeurt in constante tijd en genereert geen uitzonderingen. U gebruikt deze functie als een snelle manier om de inhoud van twee containers uit te wisselen.

Voorbeeld

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

Hiermee kopieert u de gecontroleerde reeks naar een nieuwe matrix.

Syntaxis

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

Opmerkingen

De lidfunctie retourneert een matrix die de gecontroleerde reeks bevat. U gebruikt deze om een kopie van de gecontroleerde reeks in matrixvorm te verkrijgen.

Voorbeeld

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

Hiermee verwijdert u aangrenzende elementen die aan een opgegeven test voldoen.

Syntaxis

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

Parameters

Comparer voor elementparen.

Opmerkingen

De eerste lidfunctie verwijdert uit de gecontroleerde reeks (wist) elk element dat gelijk is aan het voorgaande element - als element X voorafgaat aan het element Y en X == Y, verwijdert de lidfunctie Y. U gebruikt het om alle behalve één kopie van elke subsequence van aangrenzende elementen te verwijderen die gelijk zijn aan elkaar vergelijken. Houd er rekening mee dat als de gecontroleerde volgorde is geordend, zoals door lijst aan te roepen::sort (STL/CLR)(), de lidfunctie alleen elementen met unieke waarden achterlaat. (Vandaar de naam).

De functie tweede lid gedraagt zich hetzelfde als de eerste, behalve dat elk element wordt verwijderd Y na een element X waarvoor pred(X, Y). U gebruikt het om alle behalve één kopie van elke subsequence van aangrenzende elementen te verwijderen die voldoen aan een predicaatfunctie of gemachtigde die u opgeeft. Houd er rekening mee dat als de gecontroleerde volgorde is geordend, zoals door het aanroepen van sort(pred), de lidfunctie alleen elementen achterlaat die geen equivalente volgorde hebben met andere elementen.

Voorbeeld

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

Het type element.

Syntaxis

typedef Value value_type;

Opmerkingen

Het type is een synoniem voor de sjabloonparameter Waarde.

Voorbeeld

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

Lijst is niet gelijk aan vergelijking.

Syntaxis

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

Parameters

Container links om te vergelijken.

Juiste container om te vergelijken.

Opmerkingen

De operatorfunctie retourneert !(left == right). U gebruikt deze om te testen of linker niet hetzelfde is als rechter wanneer de twee lijsten per element worden vergeleken.

Voorbeeld

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

Lijst kleiner dan vergelijking.

Syntaxis

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

Parameters

Container links om te vergelijken.

Juiste container om te vergelijken.

Opmerkingen

De operatorfunctie retourneert waar indien, voor de laagste positie i waarvoor !(right[i] < left[i]), ook waar is dat left[i] < right[i]. Anders wordt left->size() < right->size() u deze gebruikt om te testen of linker vóór rechter wanneer de twee lijsten worden vergeleken element per element.

Voorbeeld

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

Lijst kleiner dan of gelijk aan vergelijking.

Syntaxis

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

Parameters

Container links om te vergelijken.

Juiste container om te vergelijken.

Opmerkingen

De operatorfunctie retourneert !(right < left). U gebruikt deze om te testen of linker niet is gerangschikt na rechter wanneer de twee lijsten elementen per element worden vergeleken.

Voorbeeld

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

Lijst is gelijk aan vergelijking.

Syntaxis

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

Parameters

Container links om te vergelijken.

Juiste container om te vergelijken.

Opmerkingen

De operatorfunctie retourneert alleen waar als de reeksen die worden beheerd door linker- en rechter dezelfde lengte hebben en voor elke positie ileft[i] ==right[i]. U gebruikt deze om te testen of links hetzelfde is als rechter wanneer de twee lijsten per element worden vergeleken.

Voorbeeld

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

Lijst groter dan vergelijking.

Syntaxis

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

Parameters

Container links om te vergelijken.

Juiste container om te vergelijken.

Opmerkingen

De operatorfunctie retourneert right<left. U kunt deze gebruiken om te testen of links na rechter worden gesorteerd wanneer de twee lijsten elementen per element worden vergeleken.

Voorbeeld

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

Lijst groter dan of gelijk aan vergelijking.

Syntaxis

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

Parameters

Container links om te vergelijken.

Juiste container om te vergelijken.

Opmerkingen

De operatorfunctie retourneert !(left<right). U gebruikt deze om te testen of links niet is gerangschikt voordat rechter wanneer de twee lijsten worden vergeleken met elementen.

Voorbeeld

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

Delen via

lijst (STL/CLR)

Syntaxis

Parameters

Eisen

Verklaringen

Interfaces

Opmerkingen

Leden

list::assign (STL/CLR)

Syntaxis

Parameters

Opmerkingen

Voorbeeld

list::back (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

list::back_item (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

list::begin (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

list::clear (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

list::const_iterator (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

list::const_reference (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

list::const_reverse_iterator (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

list::d ifference_type (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

list::empty (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

lijst::end (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

list::erase (STL/CLR)

Syntaxis

Parameters

Opmerkingen

Voorbeeld

list::front (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

list::front_item (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

list::generic_container (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

list::generic_iterator (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

list::generic_reverse_iterator (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

list::generic_value (STL/CLR)