deque (STL/CLR)

Artikel
02/04/2025

In de sjabloonklasse wordt een object beschreven waarmee een wisselende reeks elementen met willekeurige toegang wordt bestuurd. U gebruikt de container deque om een reeks elementen te beheren die eruitziet als een aaneengesloten opslagblok, maar die aan beide uiteinden kan groeien of verkleinen zonder dat u eventuele resterende elementen hoeft te kopiëren. Zo kan het efficiënt een double-ended queueimplementeren. (Vandaar de naam.)

In de onderstaande beschrijving is GValue hetzelfde als Value, tenzij het laatste een ref-type is, in dat geval Value^.

Syntaxis

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

Parameters

GValue-
Het algemene type element in de gecontroleerde reeks.

waarde
Het type element in de gecontroleerde reeks.

Eisen

koptekst:<cliext/deque->

naamruimte: cliext

Verklaringen

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

Lid, functie	Beschrijving
deque::assign (STL/CLR)	Vervangt alle elementen.
deque::at (STL/CLR)	Krijgt toegang tot een element op een opgegeven positie.
deque::back (STL/CLR)	Hiermee opent u het laatste element.
deque::begin (STL/CLR)	Geeft het begin van de gecontroleerde reeks aan.
deque::clear (STL/CLR)	Hiermee verwijdert u alle elementen.
deque::d eque (STL/CLR)	Maakt een containerobject.
deque::empty (STL/CLR)	Test of er geen elementen aanwezig zijn.
deque::end (STL/CLR)	Geeft het einde van de gecontroleerde reeks aan.
deque::gum (STL/CLR)	Hiermee verwijdert u elementen op opgegeven posities.
deque::front (STL/CLR)	Hiermee opent u het eerste element.
deque::insert (STL/CLR)	Voegt elementen toe op een opgegeven positie.
deque::p op_back (STL/CLR)	Hiermee verwijdert u het laatste element.
deque::p op_front (STL/CLR)	Hiermee verwijdert u het eerste element.
deque::p ush_back (STL/CLR)	Hiermee voegt u een nieuw laatste element toe.
deque::p ush_front (STL/CLR)	Hiermee voegt u een nieuw eerste element toe.
deque::rbegin (STL/CLR)	Geeft het begin van de omgekeerde gecontroleerde reeks aan.
deque::rend (STL/CLR)	Hiermee wordt het einde van de omgekeerde gecontroleerde reeks aangeduid.
deque::resize (STL/CLR)	Hiermee wijzigt u het aantal elementen.
deque::size (STL/CLR)	Telt het aantal elementen.
deque::swap (STL/CLR)	Hiermee wordt de inhoud van twee containers gewisseld.
deque::to_array (STL/CLR)	Hiermee kopieert u de gecontroleerde reeks naar een nieuwe matrix.

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

Bediener	Beschrijving
deque::operator!= (STL/CLR)	Bepaalt of twee `deque` objecten niet gelijk zijn.
deque::operator(STL/CLR)	Krijgt toegang tot een element op een opgegeven positie.
operator< (deque) (STL/CLR)	Bepaalt of een `deque` object kleiner is dan een ander `deque` object.
operator<= (deque) (STL/CLR)	Bepaalt of een `deque` object kleiner is dan of gelijk is aan een ander `deque` object.
operator= (deque) (STL/CLR)	Vervangt de gecontroleerde volgorde.
operator== (deque) (STL/CLR)	Bepaalt of een `deque` object gelijk is aan een ander `deque`-object.
operator> (deque) (STL/CLR)	Bepaalt of een `deque` object groter is dan een ander `deque` object.
operator>= (deque) (STL/CLR)	Bepaalt of een `deque` object groter is dan of gelijk is aan een ander `deque` object.

Interfaces

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

Opmerkingen

Het object wijst en maakt opslag vrij voor de volgorde die het beheert via een opgeslagen matrix met ingangen die blokken van Value elementen aanwijzen. De matrix groeit op aanvraag. De groei treedt op zodanige wijze op dat de kosten voor het voorbereiden of toevoegen van een nieuw element constante tijd zijn en dat er geen resterende elementen worden gestoord. U kunt ook een element in een constante tijd verwijderen en zonder dat de resterende elementen worden gestoord. Een deque is dus een goede kandidaat voor de onderliggende container voor sjabloonklasse wachtrij (STL/CLR) of sjabloonklasse stack (STL/CLR).

Een deque-object ondersteunt iterators voor willekeurige toegang, wat betekent dat u rechtstreeks naar een element kunt verwijzen op basis van de numerieke positie, waarbij wordt geteld van nul voor het eerste (voorste) element, tot deque::size (STL/CLR)() - 1 voor het laatste (achterste) element. Het betekent ook dat een deque een goede kandidaat is voor de onderliggende container voor sjabloonklasse priority_queue (STL/CLR).

Een iterator slaat een ingang op in het bijbehorende deque-object, samen met de vooroordelen van het element dat het aanwijst. U kunt iterators alleen gebruiken met de bijbehorende containerobjecten. De bias van een deque-element is niet noodzakelijkerwijs hetzelfde als de positie ervan. Het eerste ingevoegde element heeft vooroordelen nul, het volgende toegevoegde element heeft vooroordelen 1, maar het volgende voorgeprependeerde element heeft vooroordelen -1.

Als u elementen aan beide uiteinden invoegt of verwijdert, wordt niet de waarde van een element dat is opgeslagen bij een geldige vooroordelen, niet gewijzigd. Het invoegen of wissen van een interieurelement kan echter de elementwaarde die is opgeslagen op een bepaalde vooroordelen wijzigen, zodat de waarde die door een iterator is aangewezen ook kan veranderen. (Mogelijk moet de container elementen omhoog of omlaag kopiëren om een gat te maken voor een invoeging of om een gat te vullen na een gum.) Niettemin blijft een deque-iterator geldig zolang de vooroordelen een geldig element aanwijzen. Bovendien blijft een geldige iterator deductiebaar - u kunt deze gebruiken om de door end()geretourneerde elementwaarde te openen of te wijzigen - zolang de vooroordelen niet gelijk zijn aan de bias voor de iterator die door end()wordt geretourneerd.

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

Leden

deque::assign (STL/CLR)

Vervangt alle elementen.

Syntaxis

void assign(size_type count, value_type val);
template<typename InIt>
    void assign(InIt first, InIt last);
void assign(System::Collections::Generic::IEnumerable<Value>^ right);

Parameters

aantal
Aantal elementen dat moet worden ingevoegd.

eerste
Begin van het bereik dat moet worden ingevoegd.

laatste
Einde van het bereik dat moet worden ingevoegd.

Opsomming die moet worden ingevoegd.

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

Opmerkingen

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

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

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

Voorbeeld

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

Krijgt toegang tot een element op een opgegeven positie.

Syntaxis

reference at(size_type pos);

Parameters

pos
Positie van element voor toegang.

Opmerkingen

De lidfunctie retourneert een verwijzing naar het element van de gecontroleerde reeks op positie pos. U gebruikt het om een element te lezen of te schrijven waarvan u de positie kent.

Voorbeeld

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

Hiermee opent u het laatste element.

Syntaxis

reference back();

Opmerkingen

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

Voorbeeld

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

Hiermee opent u het laatste element.

Syntaxis

property value_type back_item;

Opmerkingen

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

Voorbeeld

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

Geeft het begin van de gecontroleerde reeks aan.

Syntaxis

iterator begin();

Opmerkingen

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

Voorbeeld

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

Hiermee verwijdert u alle elementen.

Syntaxis

void clear();

Opmerkingen

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

Voorbeeld

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

Het type van een constante iterator voor de gecontroleerde reeks.

Syntaxis

typedef T2 const_iterator;

Opmerkingen

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

Voorbeeld

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

Het type constante verwijzing naar een element.

Syntaxis

typedef value_type% const_reference;

Opmerkingen

Het type beschrijft een constante verwijzing naar een element.

Voorbeeld

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

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

Syntaxis

typedef T4 const_reverse_iterator;

Opmerkingen

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

Voorbeeld

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

Maakt een containerobject.

Syntaxis

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

Parameters

aantal
Aantal elementen dat moet worden ingevoegd.

eerste
Begin van het bereik dat moet worden ingevoegd.

laatste
Einde van het bereik dat moet worden ingevoegd.

Object of bereik dat moet worden ingevoegd.

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

Opmerkingen

De constructor:

deque();

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

De constructor:

deque(deque<Value>% right);

initialiseert de gecontroleerde reeks met de reeks [right.begin(), right.end()). U gebruikt deze om een initiële gecontroleerde reeks op te geven die een kopie is van de reeks die wordt beheerd door het dequeobject rechts. Zie deque::begin (STL/CLR) en deque::end (STL/CLR)voor meer informatie over de iterators.

De constructor:

deque(deque<Value>^ right);

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

De constructor:

explicit deque(size_type count);

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

De constructor:

deque(size_type count, value_type val);

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

De constructor:

template<typename InIt>

deque(InIt first, InIt last);

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

De constructor:

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

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

Voorbeeld

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

De typen van een ondertekende afstand tussen twee elementen.

Syntaxis

typedef int difference_type;

Opmerkingen

Het type beschrijft het aantal ondertekende elementen.

Voorbeeld

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

Test of er geen elementen aanwezig zijn.

Syntaxis

bool empty();

Opmerkingen

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

Voorbeeld

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

Geeft het einde van de gecontroleerde reeks aan.

Syntaxis

iterator end();

Opmerkingen

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

Voorbeeld

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

Hiermee verwijdert u elementen op opgegeven posities.

Syntaxis

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

Parameters

eerste
Begin van bereik om te wissen.

laatste
Einde van bereik dat moet worden gewist.

waar
Element dat moet worden gewist.

Opmerkingen

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

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

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

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

Voorbeeld

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

Hiermee opent u het eerste element.

Syntaxis

reference front();

Opmerkingen

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

Voorbeeld

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

Hiermee opent u het eerste element.

Syntaxis

property value_type front_item;

Opmerkingen

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

Voorbeeld

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

Het type van de algemene interface voor de container.

Syntaxis

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

Opmerkingen

Het type beschrijft de algemene interface voor deze sjablooncontainerklasse.

Voorbeeld

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

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

Syntaxis

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

Opmerkingen

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

Voorbeeld

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

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

Syntaxis

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

Opmerkingen

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

Voorbeeld

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

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

Syntaxis

typedef GValue generic_value;

Opmerkingen

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

Voorbeeld

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

Voegt elementen toe op een opgegeven positie.

Syntaxis

iterator insert(iterator where, value_type val);
void insert(iterator where, size_type count, value_type val);
template<typename InIt>
    void insert(iterator where, InIt first, InIt last);
void insert(iterator where,
    System::Collections::Generic::IEnumerable<Value>^ right);

Parameters

aantal
Aantal elementen dat moet worden ingevoegd.

eerste
Begin van het bereik dat moet worden ingevoegd.

laatste
Einde van het bereik dat moet worden ingevoegd.

Opsomming die moet worden ingevoegd.

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

waar
Waar in de container moet worden ingevoegd.

Opmerkingen

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

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

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

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

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

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

Voorbeeld

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

Het type iterator voor de gecontroleerde reeks.

Syntaxis

typedef T1 iterator;

Opmerkingen

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

Voorbeeld

// cliext_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 is niet gelijk aan vergelijking.

Syntaxis

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

Parameters

Container links om te vergelijken.

Juiste container om te vergelijken.

Opmerkingen

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

Voorbeeld

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

Krijgt toegang tot een element op een opgegeven positie.

Syntaxis

reference operator[](size_type pos);

Parameters

pos
Positie van element voor toegang.

Opmerkingen

De lidoperator retourneert een verwijzing naar het element op positie pos. U gebruikt het om toegang te krijgen tot een element waarvan u de positie kent.

Voorbeeld

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

Hiermee verwijdert u het laatste element.

Syntaxis

void pop_back();

Opmerkingen

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

Voorbeeld

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

Hiermee verwijdert u het eerste element.

Syntaxis

void pop_front();

Opmerkingen

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

Voorbeeld

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

Hiermee voegt u een nieuw laatste element toe.

Syntaxis

void push_back(value_type val);

Opmerkingen

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

Voorbeeld

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

Hiermee voegt u een nieuw eerste element toe.

Syntaxis

void push_front(value_type val);

Opmerkingen

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

Voorbeeld

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

Geeft het begin van de omgekeerde gecontroleerde reeks aan.

Syntaxis

reverse_iterator rbegin();

Opmerkingen

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

Voorbeeld

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

Het type verwijzing naar een element.

Syntaxis

typedef value_type% reference;

Opmerkingen

Het type beschrijft een verwijzing naar een element.

Voorbeeld

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

Hiermee wordt het einde van de omgekeerde gecontroleerde reeks aangeduid.

Syntaxis

reverse_iterator rend();

Opmerkingen

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

Voorbeeld

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

Hiermee wijzigt u het aantal elementen.

Syntaxis

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

Parameters

new_size
Nieuwe grootte van de gecontroleerde reeks.

val-
Waarde van het opvullingselement.

Opmerkingen

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

Voorbeeld

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

Het type omgekeerde iterator voor de gecontroleerde reeks.

Syntaxis

typedef T3 reverse_iterator;

Opmerkingen

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

Voorbeeld

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

Telt het aantal elementen.

Syntaxis

size_type size();

Opmerkingen

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

Voorbeeld

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

Het type ondertekende afstand tussen twee elementen.

Syntaxis

typedef int size_type;

Opmerkingen

Het type beschrijft een niet-negatief aantal elementen.

Voorbeeld

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

Hiermee wordt de inhoud van twee containers gewisseld.

Syntaxis

void swap(deque<Value>% right);

Parameters

Container waarmee inhoud moet worden gewisseld.

Opmerkingen

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

Voorbeeld

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

Hiermee kopieert u de gecontroleerde reeks naar een nieuwe matrix.

Syntaxis

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

Opmerkingen

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

Voorbeeld

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

Het type element.

Syntaxis

typedef Value value_type;

Opmerkingen

Het type is een synoniem voor de sjabloonparameter Waarde.

Voorbeeld

// 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 kleiner dan vergelijking.

Syntaxis

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

Parameters

Container links om te vergelijken.

Juiste container om te vergelijken.

Opmerkingen

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

Voorbeeld

// 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 kleiner dan of gelijk aan vergelijking.

Syntaxis

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

Parameters

Container links om te vergelijken.

Juiste container om te vergelijken.

Opmerkingen

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

Voorbeeld

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

Vervangt de gecontroleerde volgorde.

Syntaxis

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

Parameters

Te kopiëren container.

Opmerkingen

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

Voorbeeld

// cliext_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 gelijke vergelijking.

Syntaxis

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

Parameters

Container links om te vergelijken.

Juiste container om te vergelijken.

Opmerkingen

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

Voorbeeld

// 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 groter dan vergelijking.

Syntaxis

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

Parameters

Container links om te vergelijken.

Juiste container om te vergelijken.

Opmerkingen

De operatorfunctie retourneert right<left. U kunt dit gebruiken om te testen of links na rechter wordt besteld wanneer de twee deques per element worden vergeleken.

Voorbeeld

// 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 groter dan of gelijk aan vergelijking.

Syntaxis

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

Parameters

Container links om te vergelijken.

Juiste container om te vergelijken.

Opmerkingen

De operatorfunctie retourneert !(left<right). U gebruikt deze om te testen of links niet is besteld voordat rechter wanneer de twee deques per element worden vergeleken.

Voorbeeld

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

Delen via

deque (STL/CLR)

Syntaxis

Parameters

Eisen

Verklaringen

Interfaces

Opmerkingen

Leden

deque::assign (STL/CLR)

Syntaxis

Parameters

Opmerkingen

Voorbeeld

deque::at (STL/CLR)

Syntaxis

Parameters

Opmerkingen

Voorbeeld

deque::back (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

deque::back_item (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

deque::begin (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

deque::clear (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

deque::const_iterator (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

deque::const_reference (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

deque::const_reverse_iterator (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

deque::d eque (STL/CLR)

Syntaxis

Parameters

Opmerkingen

Voorbeeld

deque::d ifference_type (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

deque::empty (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

deque::end (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

deque::gum (STL/CLR)

Syntaxis

Parameters

Opmerkingen

Voorbeeld

deque::front (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

deque::front_item (STL/CLR)

Syntaxis

Opmerkingen

Voorbeeld

deque::generic_container (STL/CLR)

Syntaxis

Opmerkingen