deque (STL/CLR)

Artikel
2025-02-04

Mallklassen beskriver ett objekt som styr en sekvens med varierande längd av element som har slumpmässig åtkomst. Du använder containern deque för att hantera en sekvens med element som ser ut som ett sammanhängande lagringsblock, men som kan växa eller krympa i båda änderna utan att behöva kopiera några återstående element. Därför kan den effektivt implementera en double-ended queue. (Därav namnet.)

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 deque
        :   public
        System::ICloneable,
        System::Collections::IEnumerable,
        System::Collections::ICollection,
        System::Collections::Generic::IEnumerable<GValue>,
        System::Collections::Generic::ICollection<GValue>,
        System::Collections::Generic::IList<GValue>,
        Microsoft::VisualC::StlClr::IDeque<GValue>
    { ..... };

Parametrar

GValue
Den generiska typen av ett element i den kontrollerade sekvensen.

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

Krav

rubrik:<cliext/deque>

namnområde: cliext

Deklarationer

Typdefinition	Beskrivning
deque::const_iterator (STL/CLR)	Typen av en konstant iterator för den kontrollerade sekvensen.
deque::const_reference (STL/CLR)	Typen av en konstant referens till ett element.
deque::const_reverse_iterator (STL/CLR)	Typen av en konstant omvänd iterator för den kontrollerade sekvensen.
deque::d ifference_type (STL/CLR)	Typen av ett signerat avstånd mellan två element.
deque::generic_container (STL/CLR)	Typen av det generiska gränssnittet för containern.
deque::generic_iterator (STL/CLR)	Typen av iterator för det generiska gränssnittet för containern.
deque::generic_reverse_iterator (STL/CLR)	Typen av omvänd iterator för det generiska gränssnittet för containern.
deque::generic_value (STL/CLR)	Typ av element för det generiska gränssnittet för containern.
deque::iterator (STL/CLR)	Typ av iterator för den kontrollerade sekvensen.
deque::reference (STL/CLR)	Typen av referens till ett element.
deque::reverse_iterator (STL/CLR)	Typen av omvänd iterator för den kontrollerade sekvensen.
deque::size_type (STL/CLR)	Typen av ett signerat avstånd mellan två element.
deque::value_type (STL/CLR)	Typ av element.

Medlemsfunktion	Beskrivning
deque::assign (STL/CLR)	Ersätter alla element.
deque::at (STL/CLR)	Öppnar ett element på en angiven position.
deque::back (STL/CLR)	Öppnar det sista elementet.
deque::begin (STL/CLR)	Anger början av den kontrollerade sekvensen.
deque::clear (STL/CLR)	Tar bort alla element.
deque::d eque (STL/CLR)	Skapar ett containerobjekt.
deque::empty (STL/CLR)	Testar om det inte finns några element.
deque::end (STL/CLR)	Anger slutet på den kontrollerade sekvensen.
deque::erase (STL/CLR)	Tar bort element vid angivna positioner.
deque::front (STL/CLR)	Öppnar det första elementet.
deque::insert (STL/CLR)	Lägger till element på en angiven position.
deque::p op_back (STL/CLR)	Tar bort det sista elementet.
deque::p op_front (STL/CLR)	Tar bort det första elementet.
deque::p ush_back (STL/CLR)	Lägger till ett nytt sista element.
deque::p ush_front (STL/CLR)	Lägger till ett nytt första element.
deque::rbegin (STL/CLR)	Anger början av den omvända kontrollerade sekvensen.
deque::rend (STL/CLR)	Anger slutet på den omvända kontrollerade sekvensen.
deque::resize (STL/CLR)	Ändrar antalet element.
deque::size (STL/CLR)	Räknar antalet element.
deque::swap (STL/CLR)	Växlar innehållet i två containrar.
deque::to_array (STL/CLR)	Kopierar den kontrollerade sekvensen till en ny matris.

Egenskap	Beskrivning
deque::back_item (STL/CLR)	Öppnar det sista elementet.
deque::front_item (STL/CLR)	Öppnar det första elementet.

Operatör	Beskrivning
deque::operator!= (STL/CLR)	Avgör om två `deque` objekt inte är lika med.
deque::operator(STL/CLR)	Öppnar ett element på en angiven position.
operator< (deque) (STL/CLR)	Avgör om ett `deque` objekt är mindre än ett annat `deque` objekt.
operatorn<= (deque) (STL/CLR)	Avgör om ett `deque` objekt är mindre än eller lika med ett annat `deque` objekt.
operator= (deque) (STL/CLR)	Ersätter den kontrollerade sekvensen.
operator== (deque) (STL/CLR)	Avgör om ett `deque` objekt är lika med ett annat `deque` objekt.
operator> (deque) (STL/CLR)	Avgör om ett `deque` objekt är större än ett annat `deque` objekt.
operatorn>= (deque) (STL/CLR)	Avgör om ett `deque` objekt är större än eller lika med ett annat `deque` objekt.

Gränssnitt

Gränssnitt	Beskrivning
ICloneable	Duplicera ett objekt.
IEnumerable	Sekvens genom element.
ICollection	Underhåll en grupp med element.
IEnumerable<T>	Sekvens genom inskrivna element.
ICollection<T>	Behåll gruppen med inskrivna element.
IList<T>	Behåll en ordnad grupp med inskrivna element.
IDeque<Value>	Underhåll allmän container.

Anmärkningar

Objektet allokerar och frigör lagring för den sekvens som det styr genom en lagrad matris med referenser som anger block av Value element. Matrisen växer på begäran. Tillväxten sker på ett sådant sätt att kostnaden för att antingen vänta eller lägga till ett nytt element är konstant tid och inga återstående element störs. Du kan också ta bort ett element i endera änden i konstant tid och utan att störa återstående element. Därför är en deque en bra kandidat för den underliggande containern för mallklassen kö (STL/CLR) eller mallklass stack (STL/CLR).

Ett deque-objekt har stöd för iteratorer med slumpmässig åtkomst, vilket innebär att du kan referera till ett element direkt med tanke på dess numeriska position och räkna från noll för det första (främre) elementet till deque::size (STL/CLR)() - 1 för det sista (bakre) elementet. Det innebär också att en deque är en bra kandidat för den underliggande containern för mallklassen priority_queue (STL/CLR).

En deque-iterator lagrar ett handtag till dess associerade deque-objekt, tillsammans med biasen för det element som den anger. Du kan bara använda iteratorer med deras associerade containerobjekt. Biasen av ett deque-element är inte nödvändigtvis samma som dess position. Det första elementet som infogas har bias noll, nästa tillagda element har bias 1, men nästa förberedda element har bias -1.

Infogning eller radering av element i båda änderna inte ändra värdet för ett element som lagras vid någon giltig bias. Om du infogar eller raderar ett inre element kan dock ändra elementvärdet som lagras vid en viss bias, så att värdet som anges av en iterator också kan ändras. (Containern kan behöva kopiera element upp eller ned för att skapa ett hål före en infogning eller fylla ett hål efter en radering.) En deque-iterator är dock fortfarande giltig så länge dess bias anger ett giltigt element. Dessutom förblir 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 dess bias inte är lika med biasen för iteratorn som returneras av 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

deque::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_deque_assign.cpp
// compile with: /clr
#include <cliext/deque>

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

    // assign a repetition of values
    cliext::deque<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
    c2.assign(c1.begin(), c1.end() - 1);
    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

deque::at (STL/CLR)

Öppnar ett element på en angiven position.

Syntax

reference at(size_type pos);

Parametrar

pos
Position för element för åtkomst.

Anmärkningar

Medlemsfunktionen returnerar en referens till elementet i den kontrollerade sekvensen vid position pos. Du använder det för att läsa eller skriva ett element vars position du känner till.

Exempel

// cliext_deque_at.cpp
// compile with: /clr
#include <cliext/deque>

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

    // display contents " a b c" using at
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1.at(i));
    System::Console::WriteLine();

    // change an entry and redisplay
    c1.at(1) = L'x';
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1[i]);
    System::Console::WriteLine();
    return (0);
    }

a b c
a x c

deque::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_deque_back.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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

deque::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_deque_back_item.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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

deque::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_deque_begin.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<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

deque::clear (STL/CLR)

Tar bort alla element.

Syntax

void clear();

Anmärkningar

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

Exempel

// cliext_deque_clear.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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

deque::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_deque_const_iterator.cpp
// compile with: /clr
#include <cliext/deque>

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

    // display contents " a b c"
    cliext::deque<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

deque::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_deque_const_reference.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<wchar_t>::const_iterator cit = c1.begin();
    for (; cit != c1.end(); ++cit)
        {   // get a const reference to an element
        cliext::deque<wchar_t>::const_reference cref = *cit;
        System::Console::Write("{0} ", cref);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

deque::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_deque_const_reverse_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<wchar_t>::const_reverse_iterator crit = c1.rbegin();
    cliext::deque<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

deque::d eque (STL/CLR)

Skapar ett containerobjekt.

Syntax

deque();
deque(deque<Value>% right);
deque(deque<Value>^ right);
explicit deque(size_type count);
deque(size_type count, value_type val);
template<typename InIt>
    deque(InIt first, InIt last);
deque(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:

deque();

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

Konstruktorn:

deque(deque<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 deque-objektet höger. Mer information om iteratorerna finns i deque::begin (STL/CLR) och deque::end (STL/CLR).

Konstruktorn:

deque(deque<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 deque-objektet vars handtag är rätt.

Konstruktorn:

explicit deque(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:

deque(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>

deque(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:

deque(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_deque_construct.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
// construct an empty container
    cliext::deque<wchar_t> c1;
    System::Console::WriteLine("size() = {0}", c1.size());

    // construct with a repetition of default values
    cliext::deque<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::deque<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::deque<wchar_t>::iterator it = c3.end();
    cliext::deque<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::deque<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::deque<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::deque<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

deque::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_deque_difference_type.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<wchar_t>::difference_type diff = 0;
    for (cliext::deque<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::deque<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

deque::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 deque::size (STL/CLR)() == 0. Du använder den för att testa om deque är tom.

Exempel

// cliext_deque_empty.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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

deque::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 current slutet av den kontrollerade sekvensen, men dess status kan ändras om längden på den kontrollerade sekvensen ändras.

Exempel

// cliext_deque_end.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<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

deque::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 deque::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_deque_erase.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<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

deque::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_deque_front.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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

deque::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_deque_front_item.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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

deque::generic_container (STL/CLR)

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

Syntax

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

Anmärkningar

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

Exempel

// cliext_deque_generic_container.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<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

deque::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::
    ContainerRandomAccessIterator<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_deque_generic_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<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::deque<wchar_t>::generic_iterator gcit = gc1->begin();
    cliext::deque<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

deque::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::
    ReverseRandomAccessIterator<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_deque_generic_reverse_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<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::deque<wchar_t>::generic_reverse_iterator gcit = gc1->rbegin();
    cliext::deque<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

deque::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_deque_generic_value.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<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::deque<wchar_t>::generic_iterator gcit = gc1->begin();
    cliext::deque<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

deque::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_deque_insert.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<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::deque<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();
    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

deque::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_deque_iterator.cpp
// compile with: /clr
#include <cliext/deque>

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

    // display contents " a b c"
    cliext::deque<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

deque::operator!= (STL/CLR)

Deque inte lika jämförelse.

Syntax

template<typename Value>
    bool operator!=(deque<Value>% left,
        deque<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å deques jämförs element för element.

Exempel

// cliext_deque_operator_ne.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<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

deque::operator(STL/CLR)

Öppnar ett element på en angiven position.

Syntax

reference operator[](size_type pos);

Parametrar

pos
Position för element för åtkomst.

Anmärkningar

Medlemsoperatorn returnerar en referens till elementet vid position pos. Du använder det för att komma åt ett element vars position du känner till.

Exempel

// cliext_deque_operator_sub.cpp
// compile with: /clr
#include <cliext/deque>

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

    // display contents " a b c" using subscripting
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1[i]);
    System::Console::WriteLine();

    // change an entry and redisplay
    c1[1] = L'x';
    for (int i = 0; i < c1.size(); ++i)
        System::Console::Write("{0} ", c1[i]);
    System::Console::WriteLine();
    return (0);
    }

a b c
a x c

deque::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 deque med ett element på baksidan.

Exempel

// cliext_deque_pop_back.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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

deque::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 deque med ett element längst fram.

Exempel

// cliext_deque_pop_front.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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

deque::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 dequeen.

Exempel

// cliext_deque_push_back.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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

deque::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 till deque.

Exempel

// cliext_deque_push_front.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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

deque::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_deque_rbegin.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<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

deque::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_deque_reference.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<wchar_t>::iterator it = c1.begin();
    for (; it != c1.end(); ++it)
        {   // get a reference to an element
        cliext::deque<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::deque<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

deque::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_deque_rend.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<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

deque::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 deque::size (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 deque::size (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_deque_resize.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
// construct an empty container and pad with default values
    cliext::deque<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

deque::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_deque_reverse_iterator.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<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

deque::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 deque::empty (STL/CLR)().

Exempel

// cliext_deque_size.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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

deque::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_deque_size_type.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<wchar_t>::size_type diff = c1.end() - c1.begin();
    System::Console::WriteLine("end()-begin() = {0}", diff);
    return (0);
    }

a b c
end()-begin() = 3

deque::swap (STL/CLR)

Växlar innehållet i två containrar.

Syntax

void swap(deque<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_deque_swap.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<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

deque::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_deque_to_array.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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

deque::value_type (STL/CLR)

Typ av element.

Syntax

typedef Value value_type;

Anmärkningar

Typen är synonym för mallparametern Value.

Exempel

// cliext_deque_value_type.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<wchar_t>::iterator it = c1.begin();
        it != c1.end(); ++it)
        {   // store element in value_type object
        cliext::deque<wchar_t>::value_type val = *it;

        System::Console::Write("{0} ", val);
        }
    System::Console::WriteLine();
    return (0);
    }

a b c

`operator<` (deque) (STL/CLR)

Deque mindre än jämförelse.

Syntax

template<typename Value>
    bool operator<(deque<Value>% left,
        deque<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å deques jämförs element för element.

Exempel

// cliext_deque_operator_lt.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<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<=` (deque) (STL/CLR)

Deque mindre än eller lika jämförelse.

Syntax

template<typename Value>
    bool operator<=(deque<Value>% left,
        deque<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å deques jämförs element för element.

Exempel

// cliext_deque_operator_le.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<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= (deque) (STL/CLR)

Ersätter den kontrollerade sekvensen.

Syntax

deque<Value>% operator=(deque<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_deque_operator_as.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<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

operator== (deque) (STL/CLR)

Deque lika jämförelse.

Syntax

template<typename Value>
    bool operator==(deque<Value>% left,
        deque<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å deques jämförs element för element.

Exempel

// cliext_deque_operator_eq.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<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>` (deque) (STL/CLR)

Deque större än jämförelse.

Syntax

template<typename Value>
    bool operator>(deque<Value>% left,
        deque<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å deques jämförs element för element.

Exempel

// cliext_deque_operator_gt.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<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>=` (deque) (STL/CLR)

Deque större än eller lika jämförelse.

Syntax

template<typename Value>
    bool operator>=(deque<Value>% left,
        deque<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å deques jämförs element för element.

Exempel

// cliext_deque_operator_ge.cpp
// compile with: /clr
#include <cliext/deque>

int main()
    {
    cliext::deque<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::deque<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

Dela via

deque (STL/CLR)

Syntax

Parametrar

Krav

Deklarationer

Gränssnitt

Anmärkningar

Medlemmar

deque::assign (STL/CLR)

Syntax

Parametrar

Anmärkningar

Exempel

deque::at (STL/CLR)

Syntax

Parametrar

Anmärkningar

Exempel

deque::back (STL/CLR)

Syntax

Anmärkningar

Exempel

deque::back_item (STL/CLR)

Syntax

Anmärkningar

Exempel

deque::begin (STL/CLR)

Syntax

Anmärkningar

Exempel

deque::clear (STL/CLR)

Syntax

Anmärkningar

Exempel

deque::const_iterator (STL/CLR)

Syntax

Anmärkningar

Exempel

deque::const_reference (STL/CLR)

Syntax

Anmärkningar

Exempel

deque::const_reverse_iterator (STL/CLR)

Syntax

Anmärkningar

Exempel

deque::d eque (STL/CLR)

Syntax

Parametrar

Anmärkningar

Exempel

deque::d ifference_type (STL/CLR)

Syntax

Anmärkningar

Exempel

deque::empty (STL/CLR)

Syntax

Anmärkningar

Exempel

deque::end (STL/CLR)

Syntax

Anmärkningar

Exempel

deque::erase (STL/CLR)

Syntax

Parametrar

Anmärkningar

Exempel

deque::front (STL/CLR)

Syntax

Anmärkningar

Exempel

deque::front_item (STL/CLR)

Syntax

Anmärkningar

Exempel

deque::generic_container (STL/CLR)

Syntax

Anmärkningar