deque (STL/CLR)

Článek
10/12/2023

Třída šablony popisuje objekt, který řídí různou délkovou sekvenci prvků, které mají náhodný přístup. Kontejner slouží deque ke správě posloupnosti prvků, které vypadají jako souvislý blok úložiště, ale který se může zvětšit nebo zmenšit na obou koncích, aniž by bylo nutné kopírovat všechny zbývající prvky. Proto může efektivně double-ended queueimplementovat . (Proto název.)

V níže uvedeném popisu je stejný jako Value v případě, GValue že se jedná o typ odkazu, v jakém případě se jedná Value^o .

Syntaxe

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

Parametry

GValue
Obecný typ prvku v řízené sekvenci.

Hodnota
Typ elementu v řízené sekvenci

Požadavky

Header:<cliext/deque>

Obor názvů: cliext

Deklarace

Definice typu	Popis
deque::const_iterator (STL/CLR)	Typ konstantního iterátoru řízené sekvence
deque::const_reference (STL/CLR)	Typ konstantního odkazu na prvek
deque::const_reverse_iterator (STL/CLR)	Typ konstantního zpětného iterátoru pro řízenou sekvenci.
deque::difference_type (STL/CLR)	Typ vzdálenosti se znaménkem mezi dvěma prvky
deque::generic_container (STL/CLR)	Typ obecného rozhraní pro kontejner.
deque::generic_iterator (STL/CLR)	Typ iterátoru pro obecné rozhraní kontejneru.
deque::generic_reverse_iterator (STL/CLR)	Typ zpětného iterátoru pro obecné rozhraní kontejneru.
deque::generic_value (STL/CLR)	Typ elementu pro obecné rozhraní kontejneru.
deque::iterator (STL/CLR)	Typ iterátoru řízené sekvence
deque::reference (STL/CLR)	Typ odkazu na prvek
deque::reverse_iterator (STL/CLR)	Typ zpětné iterátoru pro řízenou sekvenci.
deque::size_type (STL/CLR)	Typ vzdálenosti se znaménkem mezi dvěma prvky
deque::value_type (STL/CLR)	Typ prvku

Členská funkce	Popis
deque::assign (STL/CLR)	Nahradí všechny prvky.
deque::at (STL/CLR)	Přistupuje k prvku na zadané pozici.
deque::back (STL/CLR)	Přistupuje k poslednímu prvku.
deque::begin (STL/CLR)	Určuje začátek řízené sekvence.
deque::clear (STL/CLR)	Odebere všechny prvky.
deque::deque (STL/CLR)	Sestaví objekt kontejneru.
deque::empty (STL/CLR)	Zkouší, zda nejsou přítomny žádné prvky.
deque::end (STL/CLR)	Určuje konec řízené sekvence.
deque::erase (STL/CLR)	Odebere prvky v určených pozicích.
deque::front (STL/CLR)	Přistupuje k prvnímu prvku.
deque::insert (STL/CLR)	Přidá prvky na zadanou pozici.
deque::pop_back (STL/CLR)	Odebere poslední prvek.
deque::pop_front (STL/CLR)	Odebere první prvek.
deque::push_back (STL/CLR)	Přidá nový poslední prvek.
deque::push_front (STL/CLR)	Přidá nový první prvek.
deque::rbegin (STL/CLR)	Určuje začátek obrácené řízené sekvence.
deque::rend (STL/CLR)	Určuje konec obrácené řízené sekvence.
deque::resize (STL/CLR)	Změní počet prvků.
deque::size (STL/CLR)	Spočítá počet prvků.
deque::swap (STL/CLR)	Zamění obsah dvou kontejnerů.
deque::to_array (STL/CLR)	Zkopíruje řízenou sekvenci do nového pole.

Vlastnost	Popis
deque::back_item (STL/CLR)	Přistupuje k poslednímu prvku.
deque::front_item (STL/CLR)	Přistupuje k prvnímu prvku.

Operátor	Popis
deque::operator!= (STL/CLR)	Určuje, zda se dva `deque` objekty nerovnají.
deque::operator(STL/CLR)	Přistupuje k prvku na zadané pozici.
operator< (deque) (STL/CLR)	Určuje, zda `deque` je objekt menší než jiný `deque` objekt.
operator<= (deque) (STL/CLR)	Určuje, zda `deque` je objekt menší nebo roven jinému `deque` objektu.
operator= (deque) (STL/CLR)	Nahradí řízenou sekvenci.
operator== (deque) (STL/CLR)	Určuje, zda je `deque` objekt roven jinému `deque` objektu.
operator> (deque) (STL/CLR)	Určuje, zda `deque` je objekt větší než jiný `deque` objekt.
operator>= (deque) (STL/CLR)	Určuje, zda `deque` je objekt větší nebo roven jinému `deque` objektu.

Rozhraní

Rozhraní	Popis
ICloneable	Duplikovat objekt
IEnumerable	Sekvencovat prvky.
ICollection	Udržujte skupinu prvků.
IEnumerable<T>	Sekvencovat přes typové prvky.
ICollection<T>	Udržujte skupinu typed elementů.
IList<T>	Udržujte seřazenou skupinu typových prvků.
Hodnota IDeque<>	Udržujte obecný kontejner.

Poznámky

Objekt přidělí a uvolní úložiště pro sekvenci, kterou řídí prostřednictvím uloženého pole popisovačů, které určují bloky Value prvků. Pole roste na vyžádání. K růstu dochází takovým způsobem, že náklady na předpendování nebo připojení nového prvku jsou konstantní čas a žádné zbývající prvky nejsou narušeny. Můžete také odebrat prvek na obou koncích v konstantním čase a bez narušení zbývajících prvků. Deque je tedy vhodným kandidátem pro podkladový kontejner pro frontu tříd šablony (STL/CLR) nebo zásobník tříd šablony (STL/CLR).

Objekt deque podporuje iterátory náhodného přístupu, což znamená, že můžete odkazovat na prvek přímo vzhledem k jeho číselné pozici, počítá se od nuly pro první (front) element, deque ::size (STL/CLR)() - 1 pro poslední (back) element. Také to znamená, že deque je vhodným kandidátem pro podkladový kontejner pro priority_queue třídy šablony (STL/CLR).

Deque iterator ukládá popisovač ke svému přidruženému deque objektu spolu s předsudky prvku, který určuje. Iterátory můžete používat pouze s přidruženými objekty kontejneru. Předsudky deque prvku nemusí být nutně stejné jako jeho pozice. První vložený prvek má zkreslení nula, další připojený prvek má předsudky 1, ale další předpended element má předsudky -1.

Vkládání nebo mazání prvků na obou koncích nemění hodnotu prvku uloženého v žádném platném předsudku. Vložení nebo vymazání vnitřní prvek však může změnit hodnotu prvku uloženou v daném předsudku, takže hodnota určená iterátorem se může také změnit. (Kontejner může muset zkopírovat prvky nahoru nebo dolů, aby se vytvořil otvor před vložením nebo vyplněním díry po vymazání.) Deque iterator však zůstává platný, pokud jeho předsudky označují platný prvek. Platný iterátor navíc zůstává nepřesunutelný – můžete ho použít k přístupu k hodnotě prvku, kterou určí, nebo ji změnit , pokud se její předsudky nerovnají předsudkům iterátoru vrácené end().

Vymazání nebo odebrání prvku volá destruktor pro uloženou hodnotu. Zničení kontejneru vymaže všechny prvky. Kontejner, jehož typ elementu je ref třída zajišťuje, že žádné prvky nedosáhly kontejneru. Všimněte si však, že kontejner popisovačů nezničí jeho prvky.

Členové

deque::assign (STL/CLR)

Nahradí všechny prvky.

Syntaxe

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

Parametry

count
Počet prvků, které se mají vložit

první
Začátek oblasti, která se má vložit.

poslední
Konec oblasti, která se má vložit.

Vpravo
Výčet pro vložení

Val
Hodnota prvku, který chcete vložit.

Poznámky

První členová funkce nahrazuje řízenou sekvenci opakováním prvků počtu hodnot val. Použijete ho k vyplnění kontejneru prvky, které mají stejnou hodnotu.

Pokud InIt je celočíselná hodnota, druhá členová funkce se chová stejně jako assign((size_type)first, (value_type)last). V opačném případě nahradí řízenou sekvenci sekvencí [first, last). Použijete ho k tomu, aby řízená sekvence byla kopie jinou sekvencí.

Třetí členová funkce nahrazuje řízenou sekvenci sekvencí určenou právem enumerátoru. Použijete ji k tomu, aby řízená sekvence byla kopií sekvence popsaná enumerátorem.

Příklad

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

Přistupuje k prvku na zadané pozici.

Syntaxe

reference at(size_type pos);

Parametry

Pos
Pozice prvku pro přístup.

Poznámky

Členová funkce vrátí odkaz na prvek řízené sekvence na pozici pos. Používáte ho ke čtení nebo zápisu prvku, jehož pozici znáte.

Příklad

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

Přistupuje k poslednímu prvku.

Syntaxe

reference back();

Poznámky

Členová funkce vrátí odkaz na poslední prvek řízené sekvence, která musí být neprázdná. Použijete ho pro přístup k poslednímu prvku, když víte, že existuje.

Příklad

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

Přistupuje k poslednímu prvku.

Syntaxe

property value_type back_item;

Poznámky

Vlastnost přistupuje k poslednímu prvku řízené sekvence, která musí být neprázdná. Použijete ho ke čtení nebo zápisu posledního prvku, pokud víte, že existuje.

Příklad

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

Určuje začátek řízené sekvence.

Syntaxe

iterator begin();

Poznámky

Členová funkce vrátí iterátor náhodného přístupu, který určuje první prvek řízené sekvence nebo těsně za koncem prázdné sekvence. Použijete ho k získání iterátoru, který určuje current začátek řízené sekvence, ale jeho stav se může změnit, pokud se změní délka řízené sekvence.

Příklad

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

Odebere všechny prvky.

Syntaxe

void clear();

Poznámky

Členská funkce efektivně volá deque::erase (STL/CLR)( deque::begin (STL/CLR)(), deque::end (STL/CLR)()). Použijete ho k zajištění, že řízená sekvence je prázdná.

Příklad

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

Typ konstantního iterátoru řízené sekvence

Syntaxe

typedef T2 const_iterator;

Poznámky

Typ popisuje objekt nezadaného typu T2 , který může sloužit jako konstantní iterátor náhodného přístupu pro řízenou sekvenci.

Příklad

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

Typ konstantního odkazu na prvek

Syntaxe

typedef value_type% const_reference;

Poznámky

Typ popisuje konstantní odkaz na prvek.

Příklad

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

Typ konstantního zpětného iterátoru pro řízenou sekvenci.

Syntaxe

typedef T4 const_reverse_iterator;

Poznámky

Typ popisuje objekt nezadaného typu T4 , který může sloužit jako konstantní reverzní iterátor pro řízenou sekvenci.

Příklad

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

Sestaví objekt kontejneru.

Syntaxe

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

Parametry

count
Počet prvků, které se mají vložit

první
Začátek oblasti, která se má vložit.

poslední
Konec oblasti, která se má vložit.

Vpravo
Objekt nebo oblast, které chcete vložit.

Val
Hodnota prvku, který chcete vložit.

Poznámky

Konstruktor:

deque();

inicializuje řízenou sekvenci bez prvků. Použijete ho k určení prázdné počáteční řízené sekvence.

Konstruktor:

deque(deque<Value>% right);

inicializuje řízenou sekvenci [right.begin(), right.end()). Použijete ho k určení počáteční řízené sekvence, která je kopií sekvence řízené deque objekt vpravo. Další informace o iterátorech najdete v tématu deque::begin (STL/CLR) a deque::end (STL/CLR).

Konstruktor:

deque(deque<Value>^ right);

inicializuje řízenou sekvenci [right->begin(), right->end()). Slouží k určení počáteční řízené sekvence, která je kopií sekvence řízené deque objekt, jehož popisovač je správný.

Konstruktor:

explicit deque(size_type count);

inicializuje řízenou sekvenci s počtem prvků každý s hodnotou value_type(). Použijete ho k vyplnění kontejneru prvky, které mají výchozí hodnotu.

Konstruktor:

deque(size_type count, value_type val);

inicializuje řízenou sekvenci s počtem prvků každý s hodnotou val. Použijete ho k vyplnění kontejneru prvky, které mají stejnou hodnotu.

Konstruktor:

template<typename InIt>

deque(InIt first, InIt last);

inicializuje řízenou sekvenci [first, last). Použijete ji k tomu, aby řízená sekvence byla kopií jiné sekvence.

Konstruktor:

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

inicializuje řízenou sekvenci sekvencí určenou zprava enumerátoru. Použijete ho k tomu, aby řízená sekvence byla kopií jiné sekvence popsané enumerátorem.

Příklad

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

Typy podepsané vzdálenosti mezi dvěma prvky.

Syntaxe

typedef int difference_type;

Poznámky

Typ popisuje počet podepsaných prvků.

Příklad

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

Zkouší, zda nejsou přítomny žádné prvky.

Syntaxe

bool empty();

Poznámky

Členová funkce vrátí hodnotu true pro prázdnou řízenou sekvenci. Je ekvivalentní deque::size (STL/CLR).() == 0 Použijete ho k otestování, jestli je deque prázdný.

Příklad

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

Určuje konec řízené sekvence.

Syntaxe

iterator end();

Poznámky

Členová funkce vrátí iterátor náhodného přístupu, který odkazuje těsně za koncem řízené sekvence. Použijete ho k získání iterátoru, který určuje current konec řízené sekvence, ale jeho stav se může změnit, pokud se změní délka řízené sekvence.

Příklad

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

Odebere prvky v určených pozicích.

Syntaxe

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

Parametry

první
Začátek rozsahu, který chcete vymazat.

poslední
Konec rozsahu, který chcete vymazat.

kde
Prvek, který chcete vymazat.

Poznámky

První členová funkce odebere prvek řízené sekvence, na kterou odkazuje místo. Použijete ho k odebrání jednoho prvku.

Druhá členová funkce odebere prvky řízené sekvence v rozsahu [first, last). Použijete ho k odebrání nulových nebo více souvislých prvků.

Obě členské funkce vrátí iterátor, který určuje první prvek, který zůstává nad rámec všech odebraných prvků, nebo deque::end (STL/CLR),() pokud žádný takový prvek neexistuje.

Při mazání prvků je počet kopií prvků lineární v počtu prvků mezi koncem mazání a nejbližším koncem sekvence. (Při mazání jednoho nebo více prvků na obou koncích sekvence nedojde k žádným kopiím prvků.)

Příklad

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

Přistupuje k prvnímu prvku.

Syntaxe

reference front();

Poznámky

Členová funkce vrátí odkaz na první prvek řízené sekvence, který musí být neprázdný. Použijete ho ke čtení nebo zápisu prvního prvku, když víte, že existuje.

Příklad

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

Přistupuje k prvnímu prvku.

Syntaxe

property value_type front_item;

Poznámky

Vlastnost přistupuje k prvnímu prvku řízené sekvence, která musí být neprázdná. Použijete ho ke čtení nebo zápisu prvního prvku, když víte, že existuje.

Příklad

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

Typ obecného rozhraní pro kontejner.

Syntaxe

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

Poznámky

Typ popisuje obecné rozhraní pro tuto třídu kontejneru šablony.

Příklad

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

Typ iterátoru pro použití s obecným rozhraním kontejneru.

Syntaxe

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

Poznámky

Typ popisuje obecný iterátor, který lze použít s obecným rozhraním pro tuto třídu kontejneru šablony.

Příklad

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

Typ zpětného iterátoru pro použití s obecným rozhraním kontejneru.

Syntaxe

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

Poznámky

Typ popisuje obecný reverzní iterátor, který lze použít s obecným rozhraním pro tuto třídu kontejneru šablony.

Příklad

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

Typ elementu pro použití s obecným rozhraním kontejneru.

Syntaxe

typedef GValue generic_value;

Poznámky

Typ popisuje objekt typu GValue , který popisuje uloženou hodnotu elementu pro použití s obecným rozhraním pro tuto třídu kontejneru šablony.

Příklad

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

Přidá prvky na zadanou pozici.

Syntaxe

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

Parametry

count
Počet prvků, které se mají vložit

první
Začátek oblasti, která se má vložit.

poslední
Konec oblasti, která se má vložit.

Vpravo
Výčet pro vložení

Val
Hodnota prvku, který chcete vložit.

kde
Kde v kontejneru vložit před.

Poznámky

Každá z členských funkcí vloží před prvek odkazovaný na místo v řízené sekvenci, posloupnost určená zbývajícími operandy.

První člen funkce vloží prvek s hodnotou val a vrátí iterátor, který určuje nově vložený prvek. Slouží k vložení jednoho prvku před místo určené iterátorem.

Druhá členová funkce vloží opakování prvků počtu hodnot val. Slouží k vložení nulových nebo více souvislých prvků, které jsou všechny kopie stejné hodnoty.

Pokud InIt je celočíselná hodnota, třetí členová funkce se chová stejně jako insert(where, (size_type)first, (value_type)last). Jinak vloží sekvenci [first, last). Slouží k vložení nulových nebo více souvislých prvků zkopírovaných z jiné sekvence.

Čtvrtá členová funkce vloží posloupnost určenou vpravo. Slouží k vložení sekvence popsané enumerátorem.

Při vkládání jednoho prvku je počet kopií prvků lineární v počtu prvků mezi kurzorem a nejbližším koncem sekvence. (Při vkládání jednoho nebo více prvků na konec sekvence nedojde k žádným kopiím prvků.) Pokud InIt je vstupní iterátor, třetí člen funkce efektivně provede pro každý prvek v sekvenci jediné vložení. V opačném případě při vkládání N prvků je počet kopií prvků lineární v N plus počet prvků mezi kurzorem a nejbližším koncem sekvence.

Příklad

// 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 iterátoru řízené sekvence

Syntaxe

typedef T1 iterator;

Poznámky

Typ popisuje objekt nezadaného typu T1 , který může sloužit jako iterátor náhodného přístupu pro řízenou sekvenci.

Příklad

// 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 not equal comparison.

Syntaxe

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

Parametry

Vlevo
Levý kontejner, který chcete porovnat.

Vpravo
Správný kontejner, který chcete porovnat.

Poznámky

Funkce operátoru vrátí !(left == right). Použijete ho k otestování, zda vlevo není seřazeno stejně jako vpravo , když dva deques jsou porovnány elementem.

Příklad

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

Přistupuje k prvku na zadané pozici.

Syntaxe

reference operator[](size_type pos);

Parametry

Pos
Pozice prvku pro přístup.

Poznámky

Operátor členu vrátí odkaz na prvek na pozici pos. Použijete ho pro přístup k prvku, jehož pozici znáte.

Příklad

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

Odebere poslední prvek.

Syntaxe

void pop_back();

Poznámky

Členová funkce odebere poslední prvek řízené sekvence, která musí být neprázdná. Použijete ho ke zkrácení deque o jeden prvek na zadní straně.

Příklad

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

Odebere první prvek.

Syntaxe

void pop_front();

Poznámky

Členová funkce odebere první prvek řízené sekvence, která musí být neprázdná. Slouží ke zkrácení deque o jeden prvek na přední straně.

Příklad

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

Přidá nový poslední prvek.

Syntaxe

void push_back(value_type val);

Poznámky

Členová funkce vloží prvek s hodnotou val na konec řízené sekvence. Použijete ho k přidání dalšího prvku do deque.

Příklad

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

Přidá nový první prvek.

Syntaxe

void push_front(value_type val);

Poznámky

Členová funkce vloží prvek s hodnotou val na začátek řízené sekvence. Použijete ho k předpřipravení dalšího prvku na deque.

Příklad

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

Určuje začátek obrácené řízené sekvence.

Syntaxe

reverse_iterator rbegin();

Poznámky

Členová funkce vrátí reverzní iterátor, který určuje poslední prvek řízené sekvence nebo těsně za začátek prázdné sekvence. Proto určuje beginning zpětnou sekvenci. Použijete ho k získání iterátoru, který určuje current začátek řízené sekvence zobrazené v obráceném pořadí, ale její stav se může změnit, pokud se délka řízené sekvence změní.

Příklad

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

Typ odkazu na prvek

Syntaxe

typedef value_type% reference;

Poznámky

Typ popisuje odkaz na prvek.

Příklad

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

Určuje konec obrácené řízené sekvence.

Syntaxe

reverse_iterator rend();

Poznámky

Členová funkce vrátí reverzní iterátor, který odkazuje přímo na začátek řízené sekvence. Proto určuje end zpětnou sekvenci. Použijete ho k získání iterátoru, který určuje current konec řízené sekvence zobrazené v obráceném pořadí, ale jeho stav se může změnit, pokud se délka řízené sekvence změní.

Příklad

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

Změní počet prvků.

Syntaxe

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

Parametry

new_size
Nová velikost řízené sekvence

Val
Hodnota odsazení prvku.

Poznámky

Členské funkce zajišťují, že funkce deque::size (STL/CLR)() od této chvíle vrátí new_size. Pokud musí být řízená sekvence delší, první členová funkce připojí prvky s hodnotou value_type(), zatímco druhá členová funkce připojí prvky s hodnotou val. Aby byla řízená sekvence kratší, obě členské funkce efektivně vymažou časy posledního prvku deque::size (STL/CLR() -new_size). Používáte ho k zajištění, že řízená sekvence má velikost new_size, a to buď oříznutím nebo odsazením aktuální řízené sekvence.

Příklad

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

Typ zpětné iterátoru pro řízenou sekvenci.

Syntaxe

typedef T3 reverse_iterator;

Poznámky

Typ popisuje objekt nespecifikovaného typu T3 , který může sloužit jako reverzní iterátor řízené sekvence.

Příklad

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

Spočítá počet prvků.

Syntaxe

size_type size();

Poznámky

Členová funkce vrátí délku řízené sekvence. Použijete ho k určení počtu prvků aktuálně v řízené sekvenci. Pokud vás zajímá, jestli má sekvence nenulovou velikost, přečtěte si téma deque::empty (STL/CLR).()

Příklad

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

Typ podepsané vzdálenosti mezi dvěma prvky.

Syntaxe

typedef int size_type;

Poznámky

Typ popisuje nezáporný počet prvků.

Příklad

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

Zamění obsah dvou kontejnerů.

Syntaxe

void swap(deque<Value>% right);

Parametry

Vpravo
Kontejner pro prohození obsahu.

Poznámky

Členová funkce prohodí řízené sekvence mezi *this a vpravo. Provede to v konstantním čase a nevyvolá žádné výjimky. Použijete ho jako rychlý způsob výměny obsahu dvou kontejnerů.

Příklad

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

Zkopíruje řízenou sekvenci do nového pole.

Syntaxe

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

Poznámky

Členová funkce vrátí matici obsahující řízenou sekvenci. Použijete ji k získání kopie řízené sekvence ve formuláři pole.

Příklad

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

Syntaxe

typedef Value value_type;

Poznámky

Typ je synonymem pro hodnotu parametru šablony.

Příklad

// 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 menší než porovnání.

Syntaxe

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

Parametry

Vlevo
Levý kontejner, který chcete porovnat.

Vpravo
Správný kontejner, který chcete porovnat.

Poznámky

Funkce operátoru vrátí hodnotu true, pokud pro nejnižší pozici i , pro kterou !(right[i] < left[i]) je také pravda left[i] < right[i]. V opačném případě se vrátí left->size() < right->size() , použijete ji k otestování, zda je vlevo seřazena před vpravo , když jsou tyto dva deques porovnány elementem.

Příklad

// 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 less than or equal comparison.

Syntaxe

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

Parametry

Vlevo
Levý kontejner, který chcete porovnat.

Vpravo
Správný kontejner, který chcete porovnat.

Poznámky

Funkce operátoru vrátí !(right < left). Použijete ho k otestování, zda vlevo není seřazeno po pravé straně, když jsou tyto dva deques porovnávány elementem.

Příklad

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

Nahradí řízenou sekvenci.

Syntaxe

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

Parametry

Vpravo
Kontejner, který se má zkopírovat.

Poznámky

Operátor člena zkopíruje právo na objekt a pak vrátí *this. Slouží k nahrazení řízené sekvence kopií řízené sekvence vpravo.

Příklad

// 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 equal comparison.

Syntaxe

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

Parametry

Vlevo
Levý kontejner, který chcete porovnat.

Vpravo
Správný kontejner, který chcete porovnat.

Poznámky

Funkce operátoru vrátí hodnotu true pouze v případě, že sekvence řízené levým a pravým tlačítkem mají stejnou délku a pro každou pozici i, right[i]left[i] == . Použijete ho k otestování, zda je vlevo seřazeno stejně jako vpravo , když jsou tyto dva deques porovnány elementem.

Příklad

// 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 větší než porovnání.

Syntaxe

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

Parametry

Vlevo
Levý kontejner, který chcete porovnat.

Vpravo
Správný kontejner, který chcete porovnat.

Poznámky

Funkce operátoru vrátí right < left. Použijete ho k otestování, zda je vlevo seřazena po pravé straně, když jsou tyto dva deques porovnány elementem.

Příklad

// 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 greater than or equal comparison.

Syntaxe

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

Parametry

Vlevo
Levý kontejner, který chcete porovnat.

Vpravo
Správný kontejner, který chcete porovnat.

Poznámky

Funkce operátoru vrátí !(left < right). Použijete ho k otestování, zda vlevo není seřazeno před vpravo , když jsou tyto dva deques porovnávány elementem.

Příklad

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

Sdílet prostřednictvím

deque (STL/CLR)

Syntaxe

Parametry

Požadavky

Deklarace

Rozhraní

Poznámky

Členové

deque::assign (STL/CLR)

Syntaxe

Parametry

Poznámky

Příklad

deque::at (STL/CLR)

Syntaxe

Parametry

Poznámky

Příklad

deque::back (STL/CLR)

Syntaxe

Poznámky

Příklad

deque::back_item (STL/CLR)

Syntaxe

Poznámky

Příklad

deque::begin (STL/CLR)

Syntaxe

Poznámky

Příklad

deque::clear (STL/CLR)

Syntaxe

Poznámky

Příklad

deque::const_iterator (STL/CLR)

Syntaxe

Poznámky

Příklad

deque::const_reference (STL/CLR)

Syntaxe

Poznámky

Příklad

deque::const_reverse_iterator (STL/CLR)

Syntaxe

Poznámky

Příklad

deque::deque (STL/CLR)

Syntaxe

Parametry

Poznámky

Příklad

deque::difference_type (STL/CLR)

Syntaxe

Poznámky

Příklad

deque::empty (STL/CLR)

Syntaxe

Poznámky

Příklad

deque::end (STL/CLR)

Syntaxe

Poznámky

Příklad

deque::erase (STL/CLR)

Syntaxe

Parametry

Poznámky

Příklad

deque::front (STL/CLR)

Syntaxe

Poznámky

Příklad

deque::front_item (STL/CLR)

Syntaxe

Poznámky

Příklad

deque::generic_container (STL/CLR)

Syntaxe

Poznámky