`deque` Třída

Článek
04/03/2024

Uspořádá prvky daného typu v lineárním uspořádání a podobně jako vektor umožňuje rychlý náhodný přístup k libovolnému prvku a efektivní vložení a odstranění na zadní straně kontejneru. Na rozdíl od vektoru deque však třída také podporuje efektivní vkládání a odstraňování na přední straně kontejneru.

Syntaxe

template <class Type, class Allocator =allocator<Type>>
class deque

Parametry

Type
Datový typ prvku, který má být uložen v souboru deque.

Allocator
Typ, který představuje uložený objekt alokátoru, který zapouzdřuje podrobnosti o dequepřidělení a uvolnění paměti. Tento argument je nepovinný a výchozí hodnota je allocator<Type>.

Poznámky

Volba typu kontejneru by měla obecně vycházet z typu vyhledávání a vkládání vyžadovaného aplikací. Vectors by měl být upřednostňovaným kontejnerem pro správu sekvence, pokud je náhodný přístup k libovolnému prvku na úrovni Premium a vložení nebo odstranění prvků jsou vyžadovány pouze na konci sekvence. Výkon kontejneru seznamu je vynikající, když efektivní vkládání a odstraňování (v konstantním čase) v libovolném umístění v rámci sekvence je na úrovni Premium. Tyto operace uprostřed sekvence vyžadují kopie prvků a přiřazení úměrné počtu prvků v sekvenci (lineární čas).

Deque reallocation nastane, když člen funkce musí vložit nebo vymazat prvky sekvence:

Pokud je prvek vložen do prázdné sekvence nebo pokud je prvek vymazán, aby opustil prázdnou sekvenci, iterátory dříve vráceny begin a end stanou se neplatnými.
Pokud je prvek vložen na první pozici deque, pak všechny iterátory, ale žádné odkazy, které označují existující prvky jsou neplatné.
Pokud je prvek vložen na konec deque, pak end a všechny iterátory, ale žádné odkazy, které označují existující prvky jsou neplatné.
Pokud je prvek vymazán na přední straně deque, pouze to, že iterátor a odkazy na odstraněný prvek se stanou neplatnými.
Pokud je poslední prvek vymazán z konce deque, pouze iterátor na konečný prvek a odkazy na odstraněný prvek se stanou neplatnými.

V opačném případě vložení nebo vymazání prvku zneplatní všechny iterátory a odkazy.

Členové

Konstruktory

Název Popis

deque Vytvoří .deque K dispozici je několik konstruktorů pro nastavení obsahu nového deque různými způsoby: prázdné, načtené se zadaným počtem prázdných prvků, obsah přesunutý nebo zkopírovaný z jiného deque; obsah zkopírován nebo přesunut pomocí iterátoru; a jeden prvek zkopírovaný do časů dequecount . Některé z konstruktorů umožňují vytvářet prvky pomocí vlastního allocator prvku.

Název	Popis
`deque`	Vytvoří .`deque` K dispozici je několik konstruktorů pro nastavení obsahu nového `deque` různými způsoby: prázdné, načtené se zadaným počtem prázdných prvků, obsah přesunutý nebo zkopírovaný z jiného `deque`; obsah zkopírován nebo přesunut pomocí iterátoru; a jeden prvek zkopírovaný do časů `dequecount` . Některé z konstruktorů umožňují vytvářet prvky pomocí vlastního `allocator` prvku.

Typedefs

Název	Popis
`allocator_type`	Typ, který představuje `allocator` třídu objektu `deque` .
`const_iterator`	Typ, který poskytuje iterátor s náhodným přístupem, který může přistupovat k prvkům `deque` a číst je jako `const`
`const_pointer`	Typ, který poskytuje ukazatel na prvek v objektu `deque` as `const`.
`const_reference`	Typ, který poskytuje odkaz na prvek v objektu `deque` pro čtení a další operace jako `const`.
`const_reverse_iterator`	Typ, který poskytuje iterátor náhodného přístupu, který může přistupovat k prvkům `deque``const`a číst je jako . Zobrazí se `deque` obráceně. Další informace najdete v tématu `reverse_iterator` Třída
`difference_type`	Typ, který poskytuje rozdíl mezi dvěma iterátory náhodného přístupu, které odkazují na prvky ve stejném `deque`.
`iterator`	Typ, který poskytuje iterátor náhodného přístupu, který může číst nebo upravovat libovolný prvek v objektu `deque`.
`pointer`	Typ, který poskytuje ukazatel na prvek v objektu `deque`.
`reference`	Typ, který poskytuje odkaz na prvek uložený v objektu `deque`.
`reverse_iterator`	Typ, který poskytuje iterátor náhodného přístupu, který může číst nebo upravovat prvek v objektu `deque`. Zobrazí se `deque` v obráceném pořadí.
`size_type`	Typ, který spočítá počet prvků v prvku `deque`.
`value_type`	Typ, který představuje datový typ uložený v objektu `deque`.

Functions

Název	Popis
`assign`	Vymaže prvky z a `deque` zkopíruje novou sekvenci prvků do cíle `deque`.
`at`	Vrátí odkaz na prvek v zadaném umístění v objektu `deque`.
`back`	Vrátí odkaz na poslední prvek objektu `deque`.
`begin`	Vrátí iterátor náhodného přístupu adresovaný prvním prvkem v objektu `deque`.
`cbegin`	`const` Vrátí iterátor na první prvek v objektu `deque`.
`cend`	Vrátí iterátor s náhodným přístupem `const` , který odkazuje těsně za koncem objektu `deque`.
`clear`	Vymaže všechny prvky .`deque`
`crbegin`	Vrátí iterátor náhodného přístupu `const` k prvnímu prvku zobrazenému `deque` v obráceném pořadí.
`crend`	Vrátí iterátor náhodného přístupu `const` k prvnímu prvku zobrazenému `deque` v obráceném pořadí.
`emplace`	Vloží prvek vytvořený na místě do `deque` zadané pozice.
`emplace_back`	Přidá prvek vytvořený na místě na konec `deque`.
`emplace_front`	Přidá prvek vytvořený na místě na začátek objektu `deque`.
`empty`	Vrátí `true` , pokud `deque` obsahuje nula prvků a `false` pokud obsahuje jeden nebo více prvků.
`end`	Vrátí iterátor s náhodným přístupem, který odkazuje těsně za koncem objektu `deque`.
`erase`	Odebere prvek nebo rozsah prvků v `deque` zadaných pozicích.
`front`	Vrátí odkaz na první prvek v objektu `deque`.
`get_allocator`	Vrátí kopii objektu `allocator` , který se používá k sestavení `deque`.
`insert`	Vloží prvek, několik prvků nebo rozsah prvků do `deque` zadané pozice.
`max_size`	Vrátí maximální možnou délku `deque`.
`pop_back`	Vymaže prvek na konci `deque`.
`pop_front`	Vymaže prvek na začátku `deque`.
`push_back`	Přidá prvek na konec `deque`.
`push_front`	Přidá prvek na začátek souboru `deque`.
`rbegin`	Vrátí iterátor náhodného přístupu k prvnímu prvku v obráceném `deque`stavu .
`rend`	Vrátí iterátor náhodného přístupu, který odkazuje těsně za posledním prvkem v obráceném objektu `deque`.
`resize`	Určuje novou velikost pro .`deque`
`shrink_to_fit`	Zahodí nadbytečnou kapacitu.
`size`	Vrátí počet prvků v sadě `deque`.
`swap`	Vymění prvky dvou `deque`s.

Operátory

Název	Popis
`operator[]`	Vrátí odkaz na `deque` prvek na zadané pozici.
`operator=`	Nahradí prvky jiného `dequedeque`.

`allocator_type`

Typ, který představuje třídu alokátoru objektu deque .

typedef Allocator allocator_type;

Poznámky

allocator_type je synonymem parametru Allocatoršablony .

Příklad

Podívejte se na příklad pro get_allocator.

`assign`

Vymaže prvky z objektu a deque zkopíruje novou sadu prvků do cíle deque.

template <class InputIterator>
void assign(
    InputIterator First,
    InputIterator Last);

void assign(
    size_type Count,
    const Type& Val);

void assign(initializer_list<Type> IList);

Parametry

First
Pozice prvního prvku v oblasti prvků, které mají být zkopírovány z argumentu deque.

Last
Pozice prvního prvku nad rozsah prvků, které mají být zkopírovány z argumentu deque.

Count
Počet kopií prvku, který je vložen do deque.

Val
Hodnota prvku, který je vložen do deque.

IList
Vkládá se initializer_list do souboru deque.

Poznámky

Po vymazání všech existujících prvků v cíli deque vloží buď zadaný rozsah prvků z původního deque nebo jiného deque prvku do cíle deque, nebo vloží kopie nového prvku zadané hodnoty do cíle deque. assign

Příklad

// deque_assign.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
#include <initializer_list>

int main()
{
    using namespace std;
    deque <int> c1, c2;
    deque <int>::const_iterator cIter;

    c1.push_back(10);
    c1.push_back(20);
    c1.push_back(30);
    c2.push_back(40);
    c2.push_back(50);
    c2.push_back(60);

    deque<int> d1{ 1, 2, 3, 4 };
    initializer_list<int> iList{ 5, 6, 7, 8 };
    d1.assign(iList);

    cout << "d1 = ";
    for (int i : d1)
        cout << i;
    cout << endl;

    cout << "c1 =";
    for (int i : c1)
        cout << i;
    cout << endl;

    c1.assign(++c2.begin(), c2.end());
    cout << "c1 =";
    for (int i : c1)
        cout << i;
    cout << endl;

    c1.assign(7, 4);
    cout << "c1 =";
    for (int i : c1)
        cout << i;
    cout << endl;
}

d1 = 5678c1 =102030c1 =5060c1 =4444444

`at`

Vrátí odkaz na prvek v zadaném umístění v objektu deque.

reference at(size_type pos);

const_reference at(size_type pos) const;

Parametry

pos
Dolní index (nebo číslo pozice) prvku, který má odkazovat v deque.

Návratová hodnota

Pokud pos je větší než velikost deque, at vyvolá výjimku.

Poznámky

Pokud je vrácená hodnota at přiřazena k objektu const_reference, deque nelze objekt změnit. Pokud je vrácená hodnota at přiřazena k objektu reference, deque lze objekt upravit.

Příklad

// deque_at.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );

   const int& i = c1.at( 0 );
   int& j = c1.at( 1 );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;
}

The first element is 10
The second element is 20

`back`

Vrátí odkaz na poslední prvek objektu deque.

reference back();
const_reference back() const;

Návratová hodnota

Poslední prvek deque. deque Pokud je tato hodnota prázdná, je vrácená hodnota nedefinovaná.

Poznámky

Pokud je vrácená hodnota back přiřazena k objektu const_reference, deque nelze objekt změnit. Pokud je vrácená hodnota back přiřazena k objektu reference, deque lze objekt upravit.

Při kompilaci pomocí _ITERATOR_DEBUG_LEVEL definovaného jako 1 nebo 2 dojde k chybě za běhu, pokud se pokusíte získat přístup k prvku v prázdném deque. Další informace najdete v tématu Kontrola iterátorů .

Příklad

// deque_back.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 11 );

   int& i = c1.back( );
   const int& ii = c1.front( );

   cout << "The last integer of c1 is " << i << endl;
   i--;
   cout << "The next-to-last integer of c1 is " << ii << endl;
}

The last integer of c1 is 11
The next-to-last integer of c1 is 10

`begin`

Vrátí iterátor adresování prvního prvku v objektu deque.

const_iterator begin() const;
iterator begin();

Návratová hodnota

Iterátor náhodného přístupu adresující první prvek v deque umístění nebo umístění, které je úspěšné prázdné deque.

Poznámky

Pokud je vrácená hodnota begin přiřazena k objektu const_iterator, deque nelze objekt změnit. Pokud je vrácená hodnota begin přiřazena k objektu iterator, deque lze objekt upravit.

Příklad

// deque_begin.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator c1_Iter;
   deque <int>::const_iterator c1_cIter;

   c1.push_back( 1 );
   c1.push_back( 2 );

   c1_Iter = c1.begin( );
   cout << "The first element of c1 is " << *c1_Iter << endl;

*c1_Iter = 20;
   c1_Iter = c1.begin( );
   cout << "The first element of c1 is now " << *c1_Iter << endl;

   // The following line would be an error because iterator is const
   // *c1_cIter = 200;
}

The first element of c1 is 1
The first element of c1 is now 20

`cbegin`

const Vrátí iterátor, který řeší první prvek v oblasti.

const_iterator cbegin() const;

Návratová hodnota

const Iterátor náhodného přístupu, který odkazuje na první prvek oblasti nebo umístění těsně za koncem prázdné oblasti (pro prázdnou oblast, cbegin() == cend()).

Poznámky

Při návratové cbeginhodnotě nelze upravit prvky v oblasti.

Tuto členská funkce můžete použít místo begin() členské funkce, abyste zajistili, že návratová hodnota je const_iterator. Obvykle se používá ve spojení s klíčovým slovem odpočtu auto typu, jak je znázorněno v následujícím příkladu. V příkladu zvažte Container , že je upravitelný (non- const) kontejner jakéhokoli druhu, který podporuje begin() a cbegin().

auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();

// i2 is Container<T>::const_iterator

`cend`

const Vrátí iterátor, který řeší umístění za posledním prvkem v rozsahu.

const_iterator cend() const;

Návratová hodnota

Iterátor pro náhodný přístup, který ukazuje přesně za konec rozsahu.

Poznámky

cend slouží k otestování, zda iterátor předal konec jeho rozsahu.

Tuto členská funkce můžete použít místo end() členské funkce, abyste zajistili, že návratová hodnota je const_iterator. Obvykle se používá ve spojení s klíčovým slovem odpočtu auto typu, jak je znázorněno v následujícím příkladu. V příkladu zvažte Container , že je upravitelný (non- const) kontejner jakéhokoli druhu, který podporuje end() a cend().

auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();

// i2 is Container<T>::const_iterator

Hodnota vrácená cend by neměla být dereferenced.

`clear`

Vymaže všechny prvky .deque

void clear();

Příklad

// deque_clear.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   cout << "The size of the deque is initially " << c1.size( ) << endl;
   c1.clear( );
   cout << "The size of the deque after clearing is " << c1.size( ) << endl;
}

The size of the deque is initially 3
The size of the deque after clearing is 0

`const_iterator`

Typ, který poskytuje iterátor náhodného přístupu, který má přístup k const prvku v objektu deque.

typedef implementation-defined const_iterator;

Poznámky

Typ const_iterator nelze použít k úpravě hodnoty elementu.

Příklad

Podívejte se na příklad pro back.

`const_pointer`

Poskytuje ukazatel na const prvek v objektu deque.

typedef typename Allocator::const_pointer const_pointer;

Poznámky

Typ const_pointer nelze použít k úpravě hodnoty elementu. Častěji iterator se používá pro přístup k deque prvku.

`const_reference`

Typ, který poskytuje odkaz na const prvek uložený v objektu deque pro čtení a provádění const operací.

typedef typename Allocator::const_reference const_reference;

Poznámky

Typ const_reference nelze použít k úpravě hodnoty elementu.

Příklad

// deque_const_ref.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );

   const deque <int> c2 = c1;
   const int &i = c2.front( );
   const int &j = c2.back( );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;

   // The following line would cause an error as c2 is const
   // c2.push_back( 30 );
}

The first element is 10
The second element is 20

`const_reverse_iterator`

Typ, který poskytuje iterátor náhodného přístupu, který může číst libovolný const prvek v objektu deque.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Poznámky

Typ const_reverse_iterator nemůže změnit hodnotu elementu a používá se k iteraci obráceně deque .

Příklad

Příklad toho, jak deklarovat a používat iterátor, najdete v příkladu rbegin .

`crbegin`

const Vrátí iterátor na první prvek v obráceném směru deque.

const_reverse_iterator crbegin() const;

Návratová hodnota

Reverzní const iterátor náhodného přístupu adresovaný prvním prvkem v obráceném deque směru nebo adresování toho, co bylo posledním prvkem v nereverze deque.

Poznámky

S návratovou crbegindeque hodnotou objektu nelze změnit.

Příklad

// deque_crbegin.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;
   deque <int>::iterator v1_Iter;
   deque <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   v1_Iter = v1.begin( );
   cout << "The first element of deque is "
        << *v1_Iter << "." << endl;

   v1_rIter = v1.crbegin( );
   cout << "The first element of the reversed deque is "
        << *v1_rIter << "." << endl;
}

The first element of deque is 1.
The first element of the reversed deque is 2.

`crend`

const Vrátí iterátor, který řeší umístění úspěšné poslední prvek v obráceném stavu deque.

const_reverse_iterator crend() const;

Návratová hodnota

Reverzní const iterátor náhodného přístupu, který řeší umístění úspěšné poslední prvek v obráceném deque stavu (umístění, které předchází prvnímu prvku v nereverze deque).

Poznámky

crend se používá s obráceným opakem deque , stejně jako array::cend se používá s deque.

Při návratové crend hodnotě (vhodnou dekrementací) deque nelze objekt upravit.

crend lze použít k otestování, zda reverzní iterátor dosáhl konce jeho deque.

Hodnota vrácená crend by neměla být dereferenced.

Příklad

// deque_crend.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;
   deque <int>::const_reverse_iterator v1_rIter;

   v1.push_back( 1 );
   v1.push_back( 2 );

   for ( v1_rIter = v1.rbegin( ) ; v1_rIter != v1.rend( ) ; v1_rIter++ )
      cout << *v1_rIter << endl;
}

2
1

`deque`

deque Vytvoří určitou velikost nebo s prvky určité hodnoty nebo s určitým alokátorem, nebo jako kopii všech nebo částí některé jiné deque.

deque();

explicit deque(const Allocator& Al);
explicit deque(size_type Count);
deque(size_type Count, const Type& Val);

deque(
    size_type Count,
    const Type& Val,
    const Allocator& Al);

deque(const deque& Right);

template <class InputIterator>
deque(InputIterator First,  InputIterator Last);

template <class InputIterator>
deque(
   InputIterator First,
   InputIterator Last,
   const Allocator& Al);

deque(initializer_list<value_type> IList, const Allocator& Al);

Parametry

Al
Třída alokátoru, která se má použít s tímto objektem.

Count
Počet prvků v vytvořeném objektu deque.

Val
Hodnota prvků v vytvořeném dequeobjektu .

Right
Z deque nichž vytvořený deque má být kopií.

First
Pozice prvního prvku v rozsahu prvků, které se mají zkopírovat.

Last
Pozice prvního prvku nad rozsah prvků, které se mají zkopírovat.

IList
Zkopíruje initializer_list se.

Poznámky

Všechny konstruktory ukládají objekt alokátoru (Al) a inicializují deque.

První dva konstruktory určují prázdný iniciály deque; druhý také určuje typ alokátoru (_Al), který se má použít.

Třetí konstruktor určuje opakování zadaného počtu (count) prvků výchozí hodnoty pro třídu Type.

Čtvrtý a pátý konstruktor určuje opakování (Count) prvků hodnoty val.

Šestý konstruktor určuje kopii dequeRight.

Sedmý a osmý konstruktor kopíruje rozsah [First, Last) a deque.

Sedmý konstruktor přesune dequeRight.

Osmý konstruktor zkopíruje obsah objektu initializer_list.

Žádná z konstruktorů neprovede žádné dočasné relokace.

Příklad

/ compile with: /EHsc
#include <deque>
#include <iostream>
#include <forward_list>

int main()
{
    using namespace std;

    forward_list<int> f1{ 1, 2, 3, 4 };

    f1.insert_after(f1.begin(), { 5, 6, 7, 8 });

    deque <int>::iterator c1_Iter, c2_Iter, c3_Iter, c4_Iter, c5_Iter, c6_Iter;

    // Create an empty deque c0
    deque <int> c0;

    // Create a deque c1 with 3 elements of default value 0
    deque <int> c1(3);

    // Create a deque c2 with 5 elements of value 2
    deque <int> c2(5, 2);

    // Create a deque c3 with 3 elements of value 1 and with the
    // allocator of deque c2
    deque <int> c3(3, 1, c2.get_allocator());

    // Create a copy, deque c4, of deque c2
    deque <int> c4(c2);

    // Create a deque c5 by copying the range c4[ first,  last)
    c4_Iter = c4.begin();
    c4_Iter++;
    c4_Iter++;
    deque <int> c5(c4.begin(), c4_Iter);

    // Create a deque c6 by copying the range c4[ first,  last) and
    // c2 with the allocator of deque
    c4_Iter = c4.begin();
    c4_Iter++;
    c4_Iter++;
    c4_Iter++;
    deque <int> c6(c4.begin(), c4_Iter, c2.get_allocator());

    // Create a deque c8 by copying the contents of an initializer_list
    // using brace initialization
    deque<int> c8({ 1, 2, 3, 4 });

    initializer_list<int> iList{ 5, 6, 7, 8 };
    deque<int> c9( iList);

    cout << "c1 = ";
    for (int i : c1)
        cout << i << " ";
    cout << endl;

    cout << "c2 = ";
    for (int i : c2)
        cout << i << " ";
    cout << endl;

    cout << "c3 = ";
    for (int i : c3)
        cout << i << " ";
    cout << endl;

    cout << "c4 = ";
    for (int i : c4)
        cout << i << " ";
    cout << endl;

    cout << "c5 = ";
    for (int i : c5)
        cout << i << " ";
    cout << endl;

    cout << "c6 = ";
    for (int i : c6)
        cout << i << " ";
    cout << endl;

    // Move deque c6 to deque c7
    deque <int> c7(move(c6));
    deque <int>::iterator c7_Iter;

    cout << "c7 =";
    for (int i : c7)
        cout << i << " ";
    cout << endl;

    cout << "c8 = ";
    for (int i : c8)
        cout << i << " ";
    cout << endl;

    cout << "c9 = ";
    for (int i : c9)
        cout << i << " ";
    cout << endl;

    int x = 3;
}
// deque_deque.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
    using namespace std;
   deque <int>::iterator c1_Iter, c2_Iter, c3_Iter, c4_Iter, c5_Iter, c6_Iter;

    // Create an empty deque c0
    deque <int> c0;

    // Create a deque c1 with 3 elements of default value 0
    deque <int> c1( 3 );

    // Create a deque c2 with 5 elements of value 2
    deque <int> c2( 5, 2 );

    // Create a deque c3 with 3 elements of value 1 and with the
    // allocator of deque c2
    deque <int> c3( 3, 1, c2.get_allocator( ) );

    // Create a copy, deque c4, of deque c2
    deque <int> c4( c2 );

    // Create a deque c5 by copying the range c4[ first,  last)
    c4_Iter = c4.begin( );
    c4_Iter++;
    c4_Iter++;
    deque <int> c5( c4.begin( ), c4_Iter );

    // Create a deque c6 by copying the range c4[ first,  last) and
    // c2 with the allocator of deque
    c4_Iter = c4.begin( );
   c4_Iter++;
   c4_Iter++;
   c4_Iter++;
   deque <int> c6( c4.begin( ), c4_Iter, c2.get_allocator( ) );

    // Create a deque c8 by copying the contents of an initializer_list
    // using brace initialization
    deque<int> c8({ 1, 2, 3, 4 });

        initializer_list<int> iList{ 5, 6, 7, 8 };
    deque<int> c9( iList);

    cout << "c1 = ";
    for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
        cout << *c1_Iter << " ";
    cout << endl;

    cout << "c2 = ";
    for ( c2_Iter = c2.begin( ); c2_Iter != c2.end( ); c2_Iter++ )
        cout << *c2_Iter << " ";
    cout << endl;

    cout << "c3 = ";
    for ( c3_Iter = c3.begin( ); c3_Iter != c3.end( ); c3_Iter++ )
        cout << *c3_Iter << " ";
    cout << endl;

    cout << "c4 = ";
    for ( c4_Iter = c4.begin( ); c4_Iter != c4.end( ); c4_Iter++ )
        cout << *c4_Iter << " ";
    cout << endl;

    cout << "c5 = ";
    for ( c5_Iter = c5.begin( ); c5_Iter != c5.end( ); c5_Iter++ )
        cout << *c5_Iter << " ";
    cout << endl;

    cout << "c6 = ";
    for ( c6_Iter = c6.begin( ); c6_Iter != c6.end( ); c6_Iter++ )
        cout << *c6_Iter << " ";
    cout << endl;

    // Move deque c6 to deque c7
    deque <int> c7( move(c6) );
    deque <int>::iterator c7_Iter;

    cout << "c7 =" ;
    for ( c7_Iter = c7.begin( ) ; c7_Iter != c7.end( ) ; c7_Iter++ )
        cout << " " << *c7_Iter;
    cout << endl;

    cout << "c8 = ";
    for (int i : c8)
        cout << i << " ";
    cout << endl;

    cout << "c9 = ";
    or (int i : c9)
        cout << i << " ";
    cout << endl;
}

`difference_type`

Typ, který poskytuje rozdíl mezi dvěma iterátory, které odkazují na prvky ve stejném deque.

typedef typename Allocator::difference_type difference_type;

Poznámky

A difference_type lze také popsat jako počet prvků mezi dvěma ukazateli.

Příklad

// deque_diff_type.cpp
// compile with: /EHsc
#include <iostream>
#include <deque>
#include <algorithm>

int main( )
{
   using namespace std;

   deque <int> c1;
   deque <int>::iterator c1_Iter, c2_Iter;

   c1.push_back( 30 );
   c1.push_back( 20 );
   c1.push_back( 30 );
   c1.push_back( 10 );
   c1.push_back( 30 );
   c1.push_back( 20 );

   c1_Iter = c1.begin( );
   c2_Iter = c1.end( );

   deque <int>::difference_type df_typ1, df_typ2, df_typ3;

   df_typ1 = count( c1_Iter, c2_Iter, 10 );
   df_typ2 = count( c1_Iter, c2_Iter, 20 );
   df_typ3 = count( c1_Iter, c2_Iter, 30 );
   cout << "The number '10' is in c1 collection " << df_typ1 << " times.\n";
   cout << "The number '20' is in c1 collection " << df_typ2 << " times.\n";
   cout << "The number '30' is in c1 collection " << df_typ3 << " times.\n";
}

The number '10' is in c1 collection 1 times.
The number '20' is in c1 collection 2 times.
The number '30' is in c1 collection 3 times.

`emplace`

Vloží prvek vytvořený na místě do deque zadané pozice.

iterator emplace(
    const_iterator _Where,
    Type&& val);

Parametry

_Where
Pozice v místě, kde deque je vložen první prvek.

val
Hodnota prvku, který je vložen do deque.

Návratová hodnota

Funkce vrátí iterátor, který odkazuje na pozici, kde byl nový prvek vložen do objektu deque.

Poznámky

Jakákoli operace vložení může být náročná, viz deque informace o výkonu deque .

Příklad

// deque_emplace.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;
   deque <int>::iterator Iter;

   v1.push_back( 10 );
   v1.push_back( 20 );
   v1.push_back( 30 );

   cout << "v1 =" ;
   for ( Iter = v1.begin( ) ; Iter != v1.end( ) ; Iter++ )
      cout << " " << *Iter;
   cout << endl;

// initialize a deque of deques by moving v1
   deque < deque <int> > vv1;

   vv1.emplace( vv1.begin(), move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      {
      cout << "vv1[0] =";
      for (Iter = vv1[0].begin( ); Iter != vv1[0].end( ); Iter++ )
         cout << " " << *Iter;
      cout << endl;
      }
}

v1 = 10 20 30
vv1[0] = 10 20 30

`emplace_back`

Přidá prvek vytvořený na místě na konec deque.

void emplace_back(Type&& val);

Parametry

val
Prvek přidaný na konec deque.

Příklad

// deque_emplace_back.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;

   v1.push_back( 1 );
   if ( v1.size( ) != 0 )
      cout << "Last element: " << v1.back( ) << endl;

   v1.push_back( 2 );
   if ( v1.size( ) != 0 )
      cout << "New last element: " << v1.back( ) << endl;

// initialize a deque of deques by moving v1
   deque < deque <int> > vv1;

   vv1.emplace_back( move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      cout << "Moved last element: " << vv1[0].back( ) << endl;
}

Last element: 1
New last element: 2
Moved last element: 2

`emplace_front`

Přidá prvek vytvořený na místě na konec deque.

void emplace_front(Type&& val);

Parametry

val
Prvek přidaný na začátek deque.

Příklad

// deque_emplace_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;

   v1.push_back( 1 );
   if ( v1.size( ) != 0 )
      cout << "Last element: " << v1.back( ) << endl;

   v1.push_back( 2 );
   if ( v1.size( ) != 0 )
      cout << "New last element: " << v1.back( ) << endl;

// initialize a deque of deques by moving v1
   deque < deque <int> > vv1;

   vv1.emplace_front( move( v1 ) );
   if ( vv1.size( ) != 0 && vv1[0].size( ) != 0 )
      cout << "Moved last element: " << vv1[0].back( ) << endl;
}

Last element: 1
New last element: 2
Moved last element: 2

`empty`

Testuje, jestli deque je prázdný.

bool empty() const;

Návratová hodnota

truedeque pokud je prázdný, false pokud deque není prázdný.

Příklad

// deque_empty.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   if ( c1.empty( ) )
      cout << "The deque is empty." << endl;
   else
      cout << "The deque is not empty." << endl;
}

The deque is not empty.

`end`

Vrátí iterátor, který řeší umístění úspěšné poslední prvek v objektu deque.

const_iterator end() const;

iterator end();

Návratová hodnota

Iterátor náhodného přístupu, který řeší umístění úspěšného posledního prvku v objektu deque. deque Pokud je prázdný, pak deque::end == deque::begin.

Poznámky

end slouží k otestování, zda iterátor dosáhl konce jeho deque.

Příklad

// deque_end.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator c1_Iter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   c1_Iter = c1.end( );
   c1_Iter--;
   cout << "The last integer of c1 is " << *c1_Iter << endl;

   c1_Iter--;
   *c1_Iter = 400;
   cout << "The new next-to-last integer of c1 is " << *c1_Iter << endl;

   // If a const iterator had been declared instead with the line:
   // deque <int>::const_iterator c1_Iter;
   // an error would have resulted when inserting the 400

   cout << "The deque is now:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
}

The last integer of c1 is 30
The new next-to-last integer of c1 is 400
The deque is now: 10 400 30

`erase`

Odebere prvek nebo rozsah prvků v deque zadaných pozicích.

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

Parametry

_Where
Pozice prvku, který má být odebrán z objektu deque.

first
Pozice prvního prvku odebraného z objektu deque.

last
Pozice těsně za posledním prvkem odebranými z objektu deque.

Návratová hodnota

Iterátor náhodného přístupu, který určuje první prvek, který zůstává nad rámec všech odebraných prvků, nebo ukazatel na konec deque prvku, pokud takový prvek neexistuje.

Poznámky

erase nikdy nevyvolá výjimku.

Příklad

// deque_erase.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator Iter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );
   c1.push_back( 40 );
   c1.push_back( 50 );
   cout << "The initial deque is: ";
   for ( Iter = c1.begin( ); Iter != c1.end( ); Iter++ )
      cout << *Iter << " ";
   cout << endl;
   c1.erase( c1.begin( ) );
   cout << "After erasing the first element, the deque becomes:  ";
   for ( Iter = c1.begin( ); Iter != c1.end( ); Iter++ )
      cout << *Iter << " ";
   cout << endl;
   Iter = c1.begin( );
   Iter++;
   c1.erase( Iter, c1.end( ) );
   cout << "After erasing all elements but the first, deque becomes: ";
   for ( Iter = c1.begin( ); Iter != c1.end( ); Iter++ )
      cout << *Iter << " ";
   cout << endl;
}

The initial deque is: 10 20 30 40 50
After erasing the first element, the deque becomes:  20 30 40 50
After erasing all elements but the first, deque becomes: 20

`front`

Vrátí odkaz na první prvek v objektu deque.

reference front();

const_reference front() const;

Návratová hodnota

deque Pokud je hodnota prázdná, návrat není definován.

Poznámky

Pokud je vrácená hodnota front přiřazena k objektu const_reference, deque nelze objekt změnit. Pokud je vrácená hodnota front přiřazena k objektu reference, deque lze objekt upravit.

Příklad

// deque_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 11 );

   int& i = c1.front( );
   const int& ii = c1.front( );

   cout << "The first integer of c1 is " << i << endl;
   i++;
   cout << "The second integer of c1 is " << ii << endl;
}

The first integer of c1 is 10
The second integer of c1 is 11

`get_allocator`

Vrátí kopii objektu alokátoru použitého k vytvoření objektu deque.

Allocator get_allocator() const;

Návratová hodnota

Alokátor používaný deque.

Poznámky

Alokátory pro deque třídu určují, jak třída spravuje úložiště. Výchozí alokátory dodávané s třídami kontejneru standardní knihovny C++ jsou dostatečné pro většinu programovacích potřeb. Psaní a používání vlastní třídy alokátoru je pokročilé téma jazyka C++.

Příklad

// deque_get_allocator.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   // The following lines declare objects that use the default allocator.
   deque <int> c1;
   deque <int, allocator<int> > c2 = deque <int, allocator<int> >( allocator<int>( ) );

   // c3 will use the same allocator class as c1
   deque <int> c3( c1.get_allocator( ) );

   deque <int>::allocator_type xlst = c1.get_allocator( );
   // You can now call functions on the allocator class used by c1
}

`insert`

Vloží prvek nebo počet prvků nebo rozsah prvků do deque zadané pozice.

iterator insert(
    const_iterator Where,
    const Type& Val);

iterator insert(
    const_iterator Where,
    Type&& Val);

void insert(
    iterator Where,
    size_type Count,
    const Type& Val);

template <class InputIterator>
void insert(
    iterator Where,
    InputIterator First,
    InputIterator Last);

iterator insert(
    iterator Where,initializer_list<Type>
IList);

Parametry

Where
Pozice v cíli deque , kde je vložen první prvek.

Val
Hodnota prvku, který je vložen do deque.

Count
Počet prvků, které jsou vloženy dequedo .

First
Pozice prvního prvku v oblasti prvků v argumentu deque , který se má zkopírovat.

Last
Pozice prvního prvku nad rozsah prvků v argumentu deque , který se má zkopírovat.

IList
Prvky initializer_list , které se mají vložit

Návratová hodnota

První dvě funkce vložení vrátí iterátor, který odkazuje na pozici, kde byl nový prvek vložen do deque.

Poznámky

Jakákoli operace vložení může být nákladná.

`iterator`

Typ, který poskytuje iterátor náhodného přístupu, který může číst nebo upravovat libovolný prvek v objektu deque.

typedef implementation-defined iterator;

Poznámky

Typ iterator lze použít k úpravě hodnoty elementu.

Příklad

Podívejte se na příklad pro begin.

`max_size`

Vrátí maximální délku deque.

size_type max_size() const;

Návratová hodnota

Maximální možnou délku deque.

Příklad

// deque_max_size.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::size_type i;

   i = c1.max_size( );
   cout << "The maximum possible length of the deque is " << i << "." << endl;
}

`operator[]`

Vrátí odkaz na deque prvek na zadané pozici.

reference operator[](size_type pos);

const_reference operator[](size_type pos) const;

Parametry

pos
Pozice deque prvku, na který se má odkazovat.

Návratová hodnota

Odkaz na prvek, jehož pozice je zadána v argumentu. Pokud je zadaná pozice větší než velikost deque, výsledek není definován.

Poznámky

Pokud je vrácená hodnota operator[] přiřazena k objektu const_reference, deque nelze objekt změnit. Pokud je vrácená hodnota operator[] přiřazena k objektu reference, deque lze objekt upravit.

Při kompilaci pomocí _ITERATOR_DEBUG_LEVEL definovaného jako 1 nebo 2 dojde k chybě za běhu, pokud se pokusíte získat přístup k prvku mimo hranice deque. Další informace najdete v tématu Kontrola iterátorů .

Příklad

// deque_op_ref.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );
   cout << "The first integer of c1 is " << c1[0] << endl;
   int& i = c1[1];
   cout << "The second integer of c1 is " << i << endl;
}

The first integer of c1 is 10
The second integer of c1 is 20

`operator=`

Nahradí prvky tohoto deque pomocí prvků z jiného deque.

deque& operator=(const deque& right);

deque& operator=(deque&& right);

Parametry

right
Ten deque poskytuje nový obsah.

Poznámky

První přepsání zkopíruje elementy z dequeright, zdroj přiřazení. Druhé přepsání přesune prvky do tohoto deque z right.

Prvky, které jsou obsaženy v této deque části před spuštěním operátoru jsou odebrány.

Příklad

// deque_operator_as.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
using namespace std;

typedef deque<int> MyDeque;

template<typename MyDeque> struct S;

template<typename MyDeque> struct S<MyDeque&> {
  static void show( MyDeque& d ) {
    MyDeque::const_iterator iter;
    for (iter = d.cbegin(); iter != d.cend(); iter++)
       cout << *iter << " ";
    cout << endl;
  }
};

template<typename MyDeque> struct S<MyDeque&&> {
  static void show( MyDeque&& d ) {
    MyDeque::const_iterator iter;
    for (iter = d.cbegin(); iter != d.cend(); iter++)
       cout << *iter << " ";
cout << " via unnamed rvalue reference " << endl;
  }
};

int main( )
{
   MyDeque d1, d2;

   d1.push_back(10);
   d1.push_back(20);
   d1.push_back(30);
   d1.push_back(40);
   d1.push_back(50);

   cout << "d1 = " ;
   S<MyDeque&>::show( d1 );

   d2 = d1;
   cout << "d2 = ";
   S<MyDeque&>::show( d2 );

   cout << "     ";
   S<MyDeque&&>::show ( move< MyDeque& > (d1) );
}

`pointer`

Poskytuje ukazatel na prvek v objektu deque.

typedef typename Allocator::pointer pointer;

Poznámky

Typ pointer lze použít k úpravě hodnoty elementu. Častěji iterator se používá pro přístup k deque prvku.

`pop_back`

Odstraní prvek na konci deque.

void pop_back();

Poznámky

Poslední prvek nesmí být prázdný. pop_back nikdy nevyvolá výjimku.

Příklad

// deque_pop_back.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 1 );
   c1.push_back( 2 );
   cout << "The first element is: " << c1.front( ) << endl;
   cout << "The last element is: " << c1.back( ) << endl;

   c1.pop_back( );
   cout << "After deleting the element at the end of the deque, the "
      "last element is: " << c1.back( ) << endl;
}

The first element is: 1
The last element is: 2
After deleting the element at the end of the deque, the last element is: 1

`pop_front`

Odstraní prvek na začátku deque.

void pop_front();

Poznámky

První prvek nesmí být prázdný. pop_front nikdy nevyvolá výjimku.

Příklad

// deque_pop_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 1 );
   c1.push_back( 2 );
   cout << "The first element is: " << c1.front( ) << endl;
   cout << "The second element is: " << c1.back( ) << endl;

   c1.pop_front( );
   cout << "After deleting the element at the beginning of the "
      "deque, the first element is: " << c1.front( ) << endl;
}

The first element is: 1
The second element is: 2
After deleting the element at the beginning of the `deque`, the first element is: 2

`push_back`

Přidá prvek na konec deque.

void push_back(const Type& val);

void push_back(Type&& val);

Parametry

val
Prvek přidaný na konec deque.

Poznámky

Pokud dojde k vyvolání výjimky, deque zůstane nezachovaná a výjimka se znovu zobrazí.

`push_front`

Přidá prvek na začátek .deque

void push_front(const Type& val);
void push_front(Type&& val);

Parametry

val
Prvek přidaný na začátek deque.

Poznámky

Pokud dojde k vyvolání výjimky, deque zůstane nezachovaná a výjimka se znovu zobrazí.

Příklad

// deque_push_front.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
#include <string>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_front( 1 );
   if ( c1.size( ) != 0 )
      cout << "First element: " << c1.front( ) << endl;

   c1.push_front( 2 );
   if ( c1.size( ) != 0 )
      cout << "New first element: " << c1.front( ) << endl;

// move initialize a deque of strings
   deque <string> c2;
   string str("a");

   c2.push_front( move( str ) );
   cout << "Moved first element: " << c2.front( ) << endl;
}

First element: 1
New first element: 2
Moved first element: a

`rbegin`

Vrátí iterátor na první prvek v obráceném směru deque.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Návratová hodnota

Reverzní iterátor náhodného přístupu adresovaný prvním prvkem v obráceném deque směru nebo adresování toho, co bylo posledním prvkem v nereverze deque.

Poznámky

rbegin se používá s obráceným opakem deque , stejně jako begin se používá s deque.

Pokud je vrácená hodnota rbegin přiřazena k objektu const_reverse_iterator, deque nelze objekt změnit. Pokud je vrácená hodnota rbegin přiřazena k objektu reverse_iterator, deque lze objekt upravit.

rbegin lze použít k iteraci zpět deque .

Příklad

// deque_rbegin.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::iterator c1_Iter;
   deque <int>::reverse_iterator c1_rIter;

   // If the following line had replaced the line above, an error
   // would have resulted in the line modifying an element
   // (commented below) because the iterator would have been const
   // deque <int>::const_reverse_iterator c1_rIter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   c1_rIter = c1.rbegin( );
   cout << "Last element in the deque is " << *c1_rIter << "." << endl;

   cout << "The deque contains the elements: ";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << *c1_Iter << " ";
   cout << "in that order.";
   cout << endl;

   // rbegin can be used to iterate through a deque in reverse order
   cout << "The reversed deque is: ";
   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )
      cout << *c1_rIter << " ";
   cout << endl;

   c1_rIter = c1.rbegin( );
   *c1_rIter = 40;  // This would have caused an error if a
                    // const_reverse iterator had been declared as
                    // noted above
   cout << "Last element in deque is now " << *c1_rIter << "." << endl;
}

Last element in the deque is 30.
The deque contains the elements: 10 20 30 in that order.
The reversed deque is: 30 20 10
Last element in deque is now 40.

`reference`

Typ, který poskytuje odkaz na prvek uložený v objektu deque.

typedef typename Allocator::reference reference;

Příklad

// deque_reference.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );

   const int &i = c1.front( );
   int &j = c1.back( );
   cout << "The first element is " << i << endl;
   cout << "The second element is " << j << endl;
}

The first element is 10
The second element is 20

`rend`

Vrátí iterátor, který řeší umístění úspěšné poslední prvek v obráceném stavu deque.

const_reverse_iterator rend() const;

reverse_iterator rend();

Návratová hodnota

Reverzní iterátor náhodného přístupu, který řeší umístění úspěšné poslední prvek v obráceném deque stavu (umístění, které předchází prvnímu prvku v nereverze deque).

Poznámky

rend se používá s obráceným opakem deque , stejně jako end se používá s deque.

Pokud je vrácená hodnota rend přiřazena k objektu const_reverse_iterator, deque nelze objekt změnit. Pokud je vrácená hodnota rend přiřazena k objektu reverse_iterator, deque lze objekt upravit.

rend lze použít k otestování, zda reverzní iterátor dosáhl konce jeho deque.

Hodnota vrácená rend by neměla být dereferenced.

Příklad

// deque_rend.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;

   deque <int> c1;
   deque <int>::iterator c1_Iter;
   deque <int>::reverse_iterator c1_rIter;
   // If the following line had replaced the line above, an error
   // would have resulted in the line modifying an element
   // (commented below) because the iterator would have been const
   // deque <int>::const_reverse_iterator c1_rIter;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   c1_rIter = c1.rend( );
   c1_rIter --; // Decrementing a reverse iterator moves it forward
                // in the deque (to point to the first element here)
   cout << "The first element in the deque is: " << *c1_rIter << endl;

   cout << "The deque is: ";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << *c1_Iter << " ";
   cout << endl;

   // rend can be used to test if an iteration is through all of
   // the elements of a reversed deque
   cout << "The reversed deque is: ";
   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )
      cout << *c1_rIter << " ";
   cout << endl;

   c1_rIter = c1.rend( );
   c1_rIter--; // Decrementing the reverse iterator moves it backward
               // in the reversed deque (to the last element here)
   *c1_rIter = 40; // This modification of the last element would
                   // have caused an error if a const_reverse
                   // iterator had been declared (as noted above)
   cout << "The modified reversed deque is: ";
   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )
      cout << *c1_rIter << " ";
   cout << endl;
}

The first element in the deque is: 10
The deque is: 10 20 30
The reversed deque is: 30 20 10
The modified reversed deque is: 30 20 40

`resize`

Určuje novou velikost pro .deque

void resize(size_type _Newsize);

void resize(size_type _Newsize, Type val);

Parametry

_Newsize
Nová velikost deque.

val
Hodnota nových prvků, které mají být přidány do deque , pokud je nová velikost větší, než původní velikost. Pokud je hodnota vynechána, nové prvky jsou přiřazeny výchozí hodnotu pro třídu.

Poznámky

dequePokud je hodnota 's size menší než _Newsize, prvky se přidají do deque doby, než dosáhne velikosti _Newsize.

dequePokud je hodnota 's size větší než _Newsize, prvky nejblíže ke konci jsou deque odstraněny, dokud deque nedosáhne velikosti _Newsize.

Pokud je současná velikost deque stejné jako _Newsize, nebude provedena žádná akce.

size odráží aktuální velikost deque.

Příklad

// deque_resize.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;

   c1.push_back( 10 );
   c1.push_back( 20 );
   c1.push_back( 30 );

   c1.resize( 4,40 );
   cout << "The size of c1 is: " << c1.size( ) << endl;
   cout << "The value of the last element is " << c1.back( ) << endl;

   c1.resize( 5 );
   cout << "The size of c1 is now: " << c1.size( ) << endl;
   cout << "The value of the last element is now " << c1.back( ) << endl;

   c1.resize( 2 );
   cout << "The reduced size of c1 is: " << c1.size( ) << endl;
   cout << "The value of the last element is now " << c1.back( ) << endl;
}

The size of c1 is: 4
The value of the last element is 40
The size of c1 is now: 5
The value of the last element is now 0
The reduced size of c1 is: 2
The value of the last element is now 20

`reverse_iterator`

Typ, který poskytuje iterátor náhodného přístupu, který může číst nebo upravovat prvek v obráceném směru deque.

typedef std::reverse_iterator<iterator> reverse_iterator;

Poznámky

Typ reverse_iterator se používá k iteraci přes deque.

Příklad

Podívejte se na příklad pro rbegin.

`shrink_to_fit`

Zahodí nadbytečnou kapacitu.

void shrink_to_fit();

Poznámky

Neexistuje žádný přenosný způsob, jak určit, zda shrink_to_fit snižuje úložiště používané nástrojem deque.

Příklad

// deque_shrink_to_fit.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> v1;
   //deque <int>::iterator Iter;

   v1.push_back( 1 );
   v1.push_back( 2 );
   cout << "Current size of v1 = "
      << v1.size( ) << endl;
   v1.shrink_to_fit();
   cout << "Current size of v1 = "
      << v1.size( ) << endl;
}

Current size of v1 = 1
Current size of v1 = 1

`size`

Vrátí počet prvků v sadě deque.

size_type size() const;

Návratová hodnota

Aktuální délka deque.

Příklad

// deque_size.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1;
   deque <int>::size_type i;

   c1.push_back( 1 );
   i = c1.size( );
   cout << "The deque length is " << i << "." << endl;

   c1.push_back( 2 );
   i = c1.size( );
   cout << "The deque length is now " << i << "." << endl;
}

The deque length is 1.
The deque length is now 2.

`size_type`

Typ, který spočítá počet prvků v prvku deque.

typedef typename Allocator::size_type size_type;

Příklad

Podívejte se na příklad pro size.

`swap`

Vymění prvky dvou deques.

void swap(deque<Type, Allocator>& right);

friend void swap(deque<Type, Allocator>& left, deque<Type, Allocator>& right) template <class Type, class Allocator>
void swap(deque<Type, Allocator>& left, deque<Type, Allocator>& right);

Parametry

right
Poskytování deque prvků, které mají být prohozeny, nebo jejichž deque prvky mají být vyměňovány s prvky dequeleft.

left
A deque jehož prvky mají být vyměňovány s prvky dequerightz .

Příklad

// deque_swap.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>

int main( )
{
   using namespace std;
   deque <int> c1, c2, c3;
   deque <int>::iterator c1_Iter;

   c1.push_back( 1 );
   c1.push_back( 2 );
   c1.push_back( 3 );
   c2.push_back( 10 );
   c2.push_back( 20 );
   c3.push_back( 100 );

   cout << "The original deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   c1.swap( c2 );

   cout << "After swapping with c2, deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   swap( c1,c3 );

   cout << "After swapping with c3, deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;

   swap<>(c1, c2);
   cout << "After swapping with c2, deque c1 is:";
   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )
      cout << " " << *c1_Iter;
   cout << endl;
}

The original deque c1 is: 1 2 3
After swapping with c2, deque c1 is: 10 20
After swapping with c3, deque c1 is: 100
After swapping with c2, deque c1 is: 1 2 3

`value_type`

Typ, který představuje datový typ uložený v objektu deque.

typedef typename Allocator::value_type value_type;

Poznámky

value_type je synonymem parametru Typešablony .

Příklad

// deque_value_type.cpp
// compile with: /EHsc
#include <deque>
#include <iostream>
int main( )
{
   using namespace std;
   deque<int>::value_type AnInt;
   AnInt = 44;
   cout << AnInt << endl;
}

Viz také

Bezpečný přístup z více vláken ve standardní knihovně C++
Standardní knihovna C++ – referenční dokumentace

deque Třída

Syntaxe

Parametry

Poznámky

Členové

Konstruktory

Typedefs

Functions

Operátory

allocator_type

Poznámky

Příklad

assign

Parametry

Poznámky

Příklad

at

Parametry

Návratová hodnota

Poznámky

Příklad

back

Návratová hodnota

Poznámky

Příklad

begin

Návratová hodnota

Poznámky

Příklad

cbegin

Návratová hodnota

Poznámky

cend

Návratová hodnota

Poznámky

clear

Příklad

const_iterator

Poznámky

Příklad

const_pointer

Poznámky

const_reference

Poznámky

Příklad

const_reverse_iterator

Poznámky

Příklad

crbegin

Návratová hodnota

Poznámky

Příklad

crend

Návratová hodnota

Poznámky

Příklad

deque

Parametry

Poznámky

Příklad

difference_type

Poznámky

Příklad

emplace

Parametry

Návratová hodnota

Poznámky

Příklad

emplace_back

Parametry

Příklad

emplace_front

Parametry

Příklad

empty

Návratová hodnota

Příklad

end

Návratová hodnota

Poznámky

`deque` Třída

`allocator_type`

`assign`

`at`

`back`

`begin`

`cbegin`

`cend`

`clear`

`const_iterator`

`const_pointer`

`const_reference`

`const_reverse_iterator`

`crbegin`

`crend`

`deque`

`difference_type`

`emplace`

`emplace_back`

`emplace_front`

`empty`

`end`

`erase`

`front`

`get_allocator`

`insert`

`iterator`

`max_size`

`operator[]`

`operator=`

`pointer`

`pop_back`

`pop_front`

`push_back`

`push_front`

`rbegin`

`reference`

`rend`

`resize`

`reverse_iterator`

`shrink_to_fit`

`size`