lista (STL/CLR)

Mallklassen beskriver ett objekt som styr en sekvens med varierande längd med element som har dubbelriktad åtkomst. Du använder containern list för att hantera en sekvens med element som en dubbelriktad länkad lista över noder som var och en lagrar ett element.

I beskrivningen nedan är GValue samma som Value om inte det senare är en referenstyp, i vilket fall det är Value^.

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

Parametrar

Värde
Typen av ett element i den kontrollerade sekvensen.

Krav

rubrik:<cliext/list>

namnområde: cliext

Deklarationer

Gränssnitt

Anmärkningar

Objektet allokerar och frigör lagring för den sekvens som det styr som enskilda noder i en dubbelriktad länklista. Den ordnar om element genom att ändra länkarna mellan noder, aldrig genom att kopiera innehållet i en nod till en annan. Det innebär att du kan infoga och ta bort element fritt utan att störa återstående element. Därför är en lista en bra kandidat för den underliggande containern för mallklassen kö (STL/CLR) eller mallklassen stack (STL/CLR).

Ett list-objekt stöder dubbelriktade iteratorer, vilket innebär att du kan gå till intilliggande element med tanke på en iterator som anger ett element i den kontrollerade sekvensen. En särskild huvudnod motsvarar iteratorn som returneras av lista::end (STL/CLR)(). Du kan minska iteratorn för att nå det sista elementet i den kontrollerade sekvensen, om det finns. Du kan öka en list-iterator för att nå huvudnoden, och den jämför sedan lika med end(). Men du kan inte avreferering av iteratorn som returneras av end().

Observera att du inte kan referera till ett listelement direkt med tanke på dess numeriska position – som kräver en iterator med slumpmässig åtkomst. En lista kan därför inte användbar som den underliggande containern för mallklassen priority_queue (STL/CLR).

En list iterator lagrar ett handtag till sin associerade listnod, som i sin tur lagrar ett handtag till sin associerade container. Du kan bara använda iteratorer med deras associerade containerobjekt. En list-iterator förblir giltig så länge dess associerade listnod är associerad med en lista. Dessutom kan en giltig iterator dereferencable – du kan använda den för att komma åt eller ändra det elementvärde som den anger – så länge den inte är lika med end().

Om du raderar eller tar bort ett element anropas destructor för dess lagrade värde. Om du förstör containern raderas alla element. En container vars elementtyp är en referensklass säkerställer därför att inga element överlever containern. Observera dock att en container med referenser inte förstöra dess element.

Medlemmar

list::assign (STL/CLR)

Ersätter alla element.

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

Parametrar

antal
Antal element som ska infogas.

första
Början av intervallet som ska infogas.

senaste
Slutet av intervallet som ska infogas.

rätt
Uppräkning som ska infogas.

val
Värdet för elementet som ska infogas.

Anmärkningar

Den första medlemsfunktionen ersätter den kontrollerade sekvensen med en upprepning av antal element i värdet val. Du använder den för att fylla containern med element som alla har samma värde.

Om InIt är en heltalstyp fungerar den andra medlemsfunktionen på samma sätt som assign((size_type)first, (value_type)last). Annars ersätter den den kontrollerade sekvensen med sekvensen [first, last). Du använder den för att göra den kontrollerade sekvensen till en kopia till en annan sekvens.

Den tredje medlemsfunktionen ersätter den kontrollerade sekvensen med sekvensen som anges av uppräknaren höger. Du använder den för att göra den kontrollerade sekvensen till en kopia av en sekvens som beskrivs av en uppräknare.

Exempel

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

Öppnar det sista elementet.

Syntax

reference back();

Anmärkningar

Medlemsfunktionen returnerar en referens till det sista elementet i den kontrollerade sekvensen, som måste vara icke-tom. Du använder det för att komma åt det sista elementet när du vet att det finns.

Exempel

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

Öppnar det sista elementet.

Syntax

property value_type back_item;

Anmärkningar

Egenskapen kommer åt det sista elementet i den kontrollerade sekvensen, som måste vara icke-tom. Du använder det för att läsa eller skriva det sista elementet när du vet att det finns.

Exempel

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

Anger början av den kontrollerade sekvensen.

Syntax

iterator begin();

Anmärkningar

Medlemsfunktionen returnerar en iterator med slumpmässig åtkomst som anger det första elementet i den kontrollerade sekvensen, eller strax efter slutet av en tom sekvens. Du använder den för att hämta en iterator som anger current början av den kontrollerade sekvensen, men dess status kan ändras om längden på den kontrollerade sekvensen ändras.

Exempel

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

Tar bort alla element.

Syntax

void clear();

Anmärkningar

Medlemsfunktionen anropar effektivt lista::radera (STL/CLR)(lista::begin (STL/CLR)(),lista::end (STL/CLR)()). Du använder den för att se till att den kontrollerade sekvensen är tom.

Exempel

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

Typen av en konstant iterator för den kontrollerade sekvensen.

Syntax

typedef T2 const_iterator;

Anmärkningar

Typen beskriver ett objekt av ospecificerad typ T2 som kan fungera som en konstant iterator med slumpmässig åtkomst för den kontrollerade sekvensen.

Exempel

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

Typen av en konstant referens till ett element.

Syntax

typedef value_type% const_reference;

Anmärkningar

Typen beskriver en konstant referens till ett element.

Exempel

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

Typen av en konstant omvänd iterator för den kontrollerade sekvensen.

Syntax

typedef T4 const_reverse_iterator;

Anmärkningar

Typen beskriver ett objekt av ospecificerad typ T4 som kan fungera som en konstant omvänd iterator för den kontrollerade sekvensen.

Exempel

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

Typerna av ett signerat avstånd mellan två element.

Syntax

typedef int difference_type;

Anmärkningar

Typen beskriver ett signerat elementantal.

Exempel

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

Testar om det inte finns några element.

Syntax

bool empty();

Anmärkningar

Medlemsfunktionen returnerar true för en tom kontrollerad sekvens. Det motsvarar lista::storlek (STL/CLR)() == 0. Du använder den för att testa om listan är tom.

Exempel

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

Anger slutet på den kontrollerade sekvensen.

Syntax

iterator end();

Anmärkningar

Medlemsfunktionen returnerar en iterator med slumpmässig åtkomst som pekar precis utanför slutet av den kontrollerade sekvensen. Du använder den för att hämta en iterator som anger slutet på den kontrollerade sekvensen. dess status ändras inte om längden på den kontrollerade sekvensen ändras.

Exempel

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

Tar bort element vid angivna positioner.

Syntax

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

Parametrar

första
Början av intervallet som ska raderas.

senaste
Slutet av intervallet som ska raderas.

där
Element som ska raderas.

Anmärkningar

Den första medlemsfunktionen tar bort elementet i den kontrollerade sekvensen som pekas på av där. Du använder det för att ta bort ett enda element.

Den andra medlemsfunktionen tar bort elementen i den kontrollerade sekvensen i intervallet [first, last). Du använder den för att ta bort noll eller fler sammanhängande element.

Båda medlemsfunktionerna returnerar en iterator som anger det första elementet som återstår utöver alla element som tas bort, eller lista::end (STL/CLR)() om det inte finns något sådant element.

Vid radering av element är antalet elementkopior linjärt i antalet element mellan slutet av radering och den närmaste änden av sekvensen. (När du raderar ett eller flera element i slutet av sekvensen sker inga elementkopior.)

Exempel

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

Öppnar det första elementet.

Syntax

reference front();

Anmärkningar

Medlemsfunktionen returnerar en referens till det första elementet i den kontrollerade sekvensen, som måste vara icke-tom. Du använder det för att läsa eller skriva det första elementet när du vet att det finns.

Exempel

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

Öppnar det första elementet.

Syntax

property value_type front_item;

Anmärkningar

Egenskapen kommer åt det första elementet i den kontrollerade sekvensen, som måste vara icke-tom. Du använder det för att läsa eller skriva det första elementet när du vet att det finns.

Exempel

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

Typen av det generiska gränssnittet för containern.

Syntax

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

Anmärkningar

Typen beskriver det allmänna gränssnittet för den här mallcontainerklassen.

Exempel

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

Typen av iterator som ska användas med det allmänna gränssnittet för containern.

Syntax

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

Anmärkningar

Typen beskriver en allmän iterator som kan användas med det allmänna gränssnittet för den här mallcontainerklassen.

Exempel

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

Typen av omvänd iterator som ska användas med det allmänna gränssnittet för containern.

Syntax

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

Anmärkningar

Typen beskriver en allmän omvänd iterator som kan användas med det allmänna gränssnittet för den här mallcontainerklassen.

Exempel

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

Typen av ett element som ska användas med det allmänna gränssnittet för containern.

Syntax

typedef GValue generic_value;

Anmärkningar

Typen beskriver ett objekt av typen GValue som beskriver det lagrade elementvärdet för användning med det allmänna gränssnittet för den här mallcontainerklassen.

Exempel

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

Lägger till element på en angiven position.

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

Parametrar

antal
Antal element som ska infogas.

första
Början av intervallet som ska infogas.

senaste
Slutet av intervallet som ska infogas.

rätt
Uppräkning som ska infogas.

val
Värdet för elementet som ska infogas.

där
Var i containern du ska infoga innan.

Anmärkningar

Var och en av medlemsfunktionerna infogar, innan elementet pekas på av där i den kontrollerade sekvensen, en sekvens som anges av de återstående operanderna.

Den första medlemsfunktionen infogar ett element med värdet val och returnerar en iterator som anger det nyligen infogade elementet. Du använder det för att infoga ett enda element före en plats som har angetts av en iterator.

Den andra medlemsfunktionen infogar en upprepning av antal element i värdet val. Du använder den för att infoga noll eller fler sammanhängande element som alla är kopior av samma värde.

Om InIt är en heltalstyp fungerar den tredje medlemsfunktionen på samma sätt som insert(where, (size_type)first, (value_type)last). Annars infogas sekvensen [first, last). Du använder den för att infoga noll eller fler sammanhängande element som kopierats från en annan sekvens.

Den fjärde medlemsfunktionen infogar sekvensen som anges av höger. Du använder den för att infoga en sekvens som beskrivs av en uppräknare.

När du infogar ett enda element är antalet elementkopior linjärt i antalet element mellan insättningspunkten och sekvensens närmaste slut. (När du infogar ett eller flera element i slutet av sekvensen sker inga elementkopior.) Om InIt är en indata-iterator utför den tredje medlemsfunktionen effektivt en enda insättning för varje element i sekvensen. När du infogar N element är annars antalet elementkopior linjärt i N plus antalet element mellan insättningspunkten och sekvensens närmaste slut.

Exempel

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

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

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

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

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

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

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

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

    return (0);
    }

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

list::iterator (STL/CLR)

Typ av iterator för den kontrollerade sekvensen.

Syntax

typedef T1 iterator;

Anmärkningar

Typen beskriver ett objekt av ospecificerad typ T1 som kan fungera som en iterator med slumpmässig åtkomst för den kontrollerade sekvensen.

Exempel

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

Skapar ett containerobjekt.

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

Parametrar

antal
Antal element som ska infogas.

första
Början av intervallet som ska infogas.

senaste
Slutet av intervallet som ska infogas.

rätt
Objekt eller område som ska infogas.

val
Värdet för elementet som ska infogas.

Anmärkningar

Konstruktorn:

list();

initierar den kontrollerade sekvensen utan element. Du använder den för att ange en tom inledande kontrollerad sekvens.

Konstruktorn:

list(list<Value>% right);

initierar den kontrollerade sekvensen med sekvensen [right.begin(), right.end()). Du använder den för att ange en inledande kontrollerad sekvens som är en kopia av sekvensen som styrs av listobjektet höger.

Konstruktorn:

list(list<Value>^ right);

initierar den kontrollerade sekvensen med sekvensen [right->begin(), right->end()). Du använder den för att ange en inledande kontrollerad sekvens som är en kopia av sekvensen som styrs av listobjektet vars handtag rätt.

Konstruktorn:

explicit list(size_type count);

initierar den kontrollerade sekvensen med antal element var och en med värdet value_type(). Du använder den för att fylla containern med element som alla har standardvärdet.

Konstruktorn:

list(size_type count, value_type val);

initierar den kontrollerade sekvensen med antal element med värdet val. Du använder den för att fylla containern med element som alla har samma värde.

Konstruktorn:

template<typename InIt>

list(InIt first, InIt last);

initierar den kontrollerade sekvensen med sekvensen [first, last). Du använder den för att göra den kontrollerade sekvensen till en kopia av en annan sekvens.

Konstruktorn:

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

initierar den kontrollerade sekvensen med sekvensen som anges av uppräknaren höger. Du använder den för att göra den kontrollerade sekvensen till en kopia av en annan sekvens som beskrivs av en uppräknare.

Exempel

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

Sammanfogar två ordnade kontrollerade sekvenser.

Syntax

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

Parametrar

före
Jämförelse för elementpar.

rätt
Container som ska sammanfogas.

Anmärkningar

Den första medlemsfunktionen tar bort alla element från sekvensen som styrs av höger och infogar dem i den kontrollerade sekvensen. Båda sekvenserna måste ordnas tidigare av operator< – element får inte minska i värde när du går igenom någon av sekvenserna. Den resulterande sekvensen sorteras också efter operator<. Du använder den här medlemsfunktionen för att sammanfoga två sekvenser som ökar i värde till en sekvens som också ökar i värde.

Den andra medlemsfunktionen fungerar på samma sätt som den första, förutom att sekvenserna ordnas efter pred -- pred(X, Y) måste vara false för alla element X som följer elementet Y i sekvensen. Du använder den för att sammanfoga två sekvenser ordnade efter en predikatfunktion eller ett ombud som du anger.

Båda funktionerna utför en stabil sammanslagning – inga elementpar i någon av de ursprungliga kontrollerade sekvenserna är omvända i den resulterande kontrollerade sekvensen. Om ett par element X och Y i den resulterande kontrollerade sekvensen har motsvarande ordning – !(X < Y) && !(X < Y) – visas ett element från den ursprungliga kontrollerade sekvensen innan ett element från sekvensen som styrs av höger.

Exempel

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

Ersätter den kontrollerade sekvensen.

Syntax

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

Parametrar

rätt
Container som ska kopieras.

Anmärkningar

Medlemsoperatorn kopierar höger till objektet och returnerar sedan *this. Du använder den för att ersätta den kontrollerade sekvensen med en kopia av den kontrollerade sekvensen i högra.

Exempel

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

Tar bort det sista elementet.

Syntax

void pop_back();

Anmärkningar

Medlemsfunktionen tar bort det sista elementet i den kontrollerade sekvensen, som måste vara icke-tom. Du använder den för att förkorta listan med ett element längst bak.

Exempel

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

Tar bort det första elementet.

Syntax

void pop_front();

Anmärkningar

Medlemsfunktionen tar bort det första elementet i den kontrollerade sekvensen, som måste vara icke-tom. Du använder den för att förkorta listan med ett element längst fram.

Exempel

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

Lägger till ett nytt sista element.

Syntax

void push_back(value_type val);

Anmärkningar

Medlemsfunktionen infogar ett element med värdet val i slutet av den kontrollerade sekvensen. Du använder det för att lägga till ett annat element i listan.

Exempel

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

Lägger till ett nytt första element.

Syntax

void push_front(value_type val);

Anmärkningar

Medlemsfunktionen infogar ett element med värdet val i början av den kontrollerade sekvensen. Du använder det för att förbereda ett annat element i listan.

Exempel

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

Anger början av den omvända kontrollerade sekvensen.

Syntax

reverse_iterator rbegin();

Anmärkningar

Medlemsfunktionen returnerar en omvänd iterator som anger det sista elementet i den kontrollerade sekvensen, eller precis utanför början av en tom sekvens. Därför anges beginning för den omvända sekvensen. Du använder den för att hämta en iterator som anger current början av den kontrollerade sekvensen som visas i omvänd ordning, men dess status kan ändras om längden på den kontrollerade sekvensen ändras.

Exempel

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

Typen av referens till ett element.

Syntax

typedef value_type% reference;

Anmärkningar

Typen beskriver en referens till ett element.

Exempel

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

Tar bort ett element med ett angivet värde.

Syntax

void remove(value_type val);

Parametrar

val
Värdet för elementet som ska tas bort.

Anmärkningar

Medlemsfunktionen tar bort ett element i den kontrollerade sekvensen där ((System::Object^)val)->Equals((System::Object^)x) är sant (om det finns några). Du använder det för att radera ett godtyckligt element med det angivna värdet.

Exempel

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

Tar bort element som klarar ett angivet test.

Syntax

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

Parametrar

före
Testa för element att ta bort.

Anmärkningar

Medlemsfunktionen tar bort från den kontrollerade sekvensen (raderar) varje element X som pred(X) är sant för. Du använder den för att ta bort alla element som uppfyller ett villkor som du anger som en funktion eller ett ombud.

Exempel

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

Anger slutet på den omvända kontrollerade sekvensen.

Syntax

reverse_iterator rend();

Anmärkningar

Medlemsfunktionen returnerar en omvänd iterator som pekar precis utanför början av den kontrollerade sekvensen. Därför anges end för den omvända sekvensen. Du använder den för att hämta en iterator som anger current slutet av den kontrollerade sekvensen som visas i omvänd ordning, men dess status kan ändras om längden på den kontrollerade sekvensen ändras.

Exempel

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

Ändrar antalet element.

Syntax

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

Parametrar

new_size
Ny storlek på den kontrollerade sekvensen.

val
Värdet för utfyllnadselementet.

Anmärkningar

Medlemsfunktionerna ser båda till att lista::storlek (STL/CLR)() returnerar hädanefter new_size. Om den måste göra den kontrollerade sekvensen längre lägger den första medlemsfunktionen till element med värdet value_type(), medan den andra medlemsfunktionen lägger till element med värdet val. För att göra den kontrollerade sekvensen kortare raderar båda medlemsfunktionerna effektivt det sista elementet lista::storlek (STL/CLR)() -new_size gånger. Du använder den för att se till att den kontrollerade sekvensen har storleken new_sizegenom att antingen trimma eller utfyllnad av den aktuella kontrollerade sekvensen.

Exempel

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

Vänder den kontrollerade sekvensen.

Syntax

void reverse();

Anmärkningar

Medlemsfunktionen ändrar ordningen på alla element i den kontrollerade sekvensen. Du använder den för att visa en lista över element.

Exempel

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

Typen av omvänd iterator för den kontrollerade sekvensen.

Syntax

typedef T3 reverse_iterator;

Anmärkningar

Typen beskriver ett objekt av ospecificerad typ T3 som kan fungera som omvänd iterator för den kontrollerade sekvensen.

Exempel

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

Räknar antalet element.

Syntax

size_type size();

Anmärkningar

Medlemsfunktionen returnerar längden på den kontrollerade sekvensen. Du använder den för att fastställa antalet element som för närvarande finns i den kontrollerade sekvensen. Om allt du bryr dig om är om sekvensen har en icke-nollstorlek kan du läsa lista::empty (STL/CLR)().

Exempel

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

Typen av ett signerat avstånd mellan två element.

Syntax

typedef int size_type;

Anmärkningar

Typen beskriver ett icke-negativt elementantal.

Exempel

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

Beställer den kontrollerade sekvensen.

Syntax

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

Parametrar

före
Jämförelse för elementpar.

Anmärkningar

Den första medlemsfunktionen ordnar om elementen i den kontrollerade sekvensen så att de sorteras efter operator< – elementen minskar inte i värde när du går igenom sekvensen. Du använder den här medlemsfunktionen för att sortera sekvensen i ökande ordning.

Den andra medlemsfunktionen fungerar på samma sätt som den första, förutom att sekvensen ordnas efter pred -- pred(X, Y) är false för alla element X som följer elementet Y i den resulterande sekvensen. Du använder den för att sortera sekvensen i en ordning som du anger efter en predikatfunktion eller ett ombud.

Båda funktionerna utför en stabil sortering – inga elementpar i den ursprungliga kontrollerade sekvensen är omvända i den resulterande kontrollerade sekvensen.

Exempel

// 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-länkar mellan noder.

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

Parametrar

första
Början av intervallet att skarva.

senaste
Slutet av intervallet som ska skarvas.

rätt
Container att skarva från.

där
Var i containern som ska skarvas innan.

Anmärkningar

Den första medlemsfunktionen infogar sekvensen som styrs av höger innan elementet i den kontrollerade sekvensen pekas på av där. Den tar också bort alla element från höger. (%right får inte vara lika med this.) Du använder den för att dela upp alla en lista i en annan.

Den andra medlemsfunktionen tar bort elementet som pekas på av första i sekvensen som styrs av höger och infogar det före elementet i den kontrollerade sekvensen som pekas på av där. (Om where==first||where== ++firstsker ingen ändring.) Du använder den för att skarva ett enda element i en lista i en annan.

Den tredje medlemsfunktionen infogar underordningen som anges av [first, last) från sekvensen som styrs av höger innan elementet i den kontrollerade sekvensen pekas på av där. Den tar också bort den ursprungliga underordningen från sekvensen som styrs av höger. (Om right == thisfår intervallet [first, last) inte innehålla elementet som pekas på av där.) Du använder den för att skarva en delmängd av noll eller flera element från en lista till en annan.

Exempel

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

Växlar innehållet i två containrar.

Syntax

void swap(list<Value>% right);

Parametrar

rätt
Container att växla innehåll med.

Anmärkningar

Medlemsfunktionen växlar de kontrollerade sekvenserna mellan *this och höger. Det gör det i konstant tid och det genererar inga undantag. Du använder det som ett snabbt sätt att utbyta innehållet i två containrar.

Exempel

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

Kopierar den kontrollerade sekvensen till en ny matris.

Syntax

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

Anmärkningar

Medlemsfunktionen returnerar en matris som innehåller den kontrollerade sekvensen. Du använder den för att hämta en kopia av den kontrollerade sekvensen i matrisform.

Exempel

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

Tar bort intilliggande element som klarar ett angivet test.

Syntax

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

Parametrar

före
Jämförelse för elementpar.

Anmärkningar

Den första medlemsfunktionen tar bort från den kontrollerade sekvensen (raderar) varje element som jämförs med dess föregående element – om elementet X föregår elementet Y och X == Ytar medlemsfunktionen bort Y. Du använder den för att ta bort alla utom en kopia av varje delmängd av intilliggande element som jämför lika. Observera att om den kontrollerade sekvensen sorteras, till exempel genom att anropa lista::sort (STL/CLR)()lämnar medlemsfunktionen endast element med unika värden. (Därav namnet).

Den andra medlemsfunktionen fungerar på samma sätt som den första, förutom att den tar bort varje element Y efter ett element X som pred(X, Y). Du använder den för att ta bort alla utom en kopia av varje delmängd av intilliggande element som uppfyller en predikatfunktion eller ombud som du anger. Observera att om den kontrollerade sekvensen sorteras, till exempel genom att anropa sort(pred), lämnar medlemsfunktionen endast element som inte har motsvarande ordning med andra element.

Exempel

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

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

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

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

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

a a b c
a b c
a a

list::value_type (STL/CLR)

Typ av element.

Syntax

typedef Value value_type;

Anmärkningar

Typen är synonym för mallparametern Value.

Exempel

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

Visa en lista som inte är lika med jämförelse.

Syntax

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

Parametrar

vänster
Vänster container att jämföra.

rätt
Rätt container att jämföra.

Anmärkningar

Operatorfunktionen returnerar !(left == right). Du använder den för att testa om vänstra inte sorteras på samma sätt som höger när de två listorna jämförs element för element.

Exempel

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

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

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

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

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

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

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

operator< (lista) (STL/CLR)

Visa en lista som är mindre än jämförelse.

Syntax

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

Parametrar

vänster
Vänster container att jämföra.

rätt
Rätt container att jämföra.

Anmärkningar

Operatorfunktionen returnerar sant om, för den lägsta positionen i för vilken !(right[i] < left[i]) är det också sant att left[i] < right[i]. Annars returneras left->size() < right->size() Du använder den för att testa om vänstra ordnas innan höger när de två listorna jämförs element för element.

Exempel

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

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

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

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

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

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

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

operator<= (lista) (STL/CLR)

Visa en lista som är mindre än eller lika med jämförelse.

Syntax

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

Parametrar

vänster
Vänster container att jämföra.

rätt
Rätt container att jämföra.

Anmärkningar

Operatorfunktionen returnerar !(right < left). Du använder den för att testa om vänstra inte ordnas efter höger när de två listorna jämförs element för element.

Exempel

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

Visa en lista med samma jämförelse.

Syntax

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

Parametrar

vänster
Vänster container att jämföra.

rätt
Rätt container att jämföra.

Anmärkningar

Operatorfunktionen returnerar endast sant om sekvenserna som styrs av vänstra och höger har samma längd och för varje position ileft[i] ==right[i]. Du använder den för att testa om vänstra sorteras på samma sätt som höger när de två listorna jämförs element för element.

Exempel

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

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

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

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

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

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

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

operator> (lista) (STL/CLR)

Lista som är större än jämförelse.

Syntax

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

Parametrar

vänster
Vänster container att jämföra.

rätt
Rätt container att jämföra.

Anmärkningar

Operatorfunktionen returnerar right<left. Du använder den för att testa om vänstra ordnas efter höger när de två listorna jämförs element för element.

Exempel

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

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

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

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

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

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

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

operator>= (lista) (STL/CLR)

Visa en lista som är större än eller lika med jämförelsen.

Syntax

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

Parametrar

vänster
Vänster container att jämföra.

rätt
Rätt container att jämföra.

Anmärkningar

Operatorfunktionen returnerar !(left<right). Du använder den för att testa om vänstra inte ordnas innan höger när de två listorna jämförs element för element.

Exempel

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