`deque` Classe

Artigo
03/11/2025

Organiza elementos de um determinado tipo em um arranjo linear e, como um vetor, permite acesso aleatório rápido a qualquer elemento, e inserção e exclusão eficientes na parte traseira do contêiner. No entanto, ao contrário de um vetor, a classe deque também suporta inserção e exclusão eficientes na frente do contêiner.

Sintaxe

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

Parâmetros

Type
O tipo de dados do elemento a ser armazenado no deque.

Allocator
O tipo que representa o objeto alocador armazenado que encapsula detalhes sobre a alocação e desalocação de memória do deque. Esse argumento é opcional e o valor padrão é allocator<Type>.

Comentários

A escolha do tipo de contentor deve basear-se, em geral, no tipo de pesquisa e inserção exigido pela aplicação. Vectors deve ser o recipiente preferido para gerenciar uma sequência quando o acesso aleatório a qualquer elemento é um prêmio e inserções ou exclusões de elementos só são necessárias no final de uma sequência. O desempenho do contêiner de lista é superior quando inserções e exclusões eficientes (em tempo constante) em qualquer local dentro da sequência são um prêmio. Tais operações no meio da sequência requerem cópias de elementos e atribuições proporcionais ao número de elementos na sequência (tempo linear).

Deque realocação ocorre quando uma função membro deve inserir ou apagar elementos da sequência:

Se um elemento for inserido em uma sequência vazia, ou se um elemento for apagado para deixar uma sequência vazia, os iteradores retornados anteriormente por begin e end se tornarão inválidos.
Se um elemento for inserido na primeira posição do deque, todos os iteradores, mas nenhuma referência, que designam elementos existentes se tornarão inválidos.
Se um elemento for inserido no final do deque, end e todos os iteradores, mas nenhuma referência, que designam elementos existentes se tornarão inválidos.
Se um elemento for apagado na frente do deque, somente esse iterador e as referências ao elemento apagado se tornarão inválidos.
Se o último elemento for apagado do final do deque, somente o iterador para o elemento final e as referências ao elemento apagado se tornarão inválidos.

Caso contrário, inserir ou apagar um elemento invalidará todos os iteradores e referências.

Membros

Construtores

Designação Descrição

deque Constrói um deque. Vários construtores são fornecidos para configurar o conteúdo do novo deque de maneiras diferentes: vazio; carregado com um número especificado de elementos vazios; conteúdos movidos ou copiados de outra deque; conteúdos copiados ou movidos usando um iterador; e um elemento copiado para o dequecount vezes. Alguns dos construtores permitem o uso de um allocator personalizado para criar elementos.

Designação	Descrição
`deque`	Constrói um `deque`. Vários construtores são fornecidos para configurar o conteúdo do novo `deque` de maneiras diferentes: vazio; carregado com um número especificado de elementos vazios; conteúdos movidos ou copiados de outra `deque`; conteúdos copiados ou movidos usando um iterador; e um elemento copiado para o `dequecount` vezes. Alguns dos construtores permitem o uso de um `allocator` personalizado para criar elementos.

Typedefs

Designação	Descrição
`allocator_type`	Um tipo que representa a classe `allocator` para o objeto `deque`.
`const_iterator`	Um tipo que fornece um iterador de acesso aleatório que pode acessar e ler elementos no `deque` como `const`
`const_pointer`	Um tipo que fornece um ponteiro para um elemento em um `deque` como `const`.
`const_reference`	Um tipo que fornece uma referência a um elemento em um `deque` para leitura e outras operações como `const`.
`const_reverse_iterator`	Um tipo que fornece um iterador de acesso aleatório que pode acessar e ler elementos no `deque` como `const`. A `deque` é vista ao contrário. Para obter mais informações, consulte `reverse_iterator` Class
`difference_type`	Um tipo que fornece a diferença entre dois iteradores de acesso aleatório que se referem a elementos no mesmo `deque`.
`iterator`	Um tipo que fornece um iterador de acesso aleatório que pode ler ou modificar qualquer elemento em um `deque`.
`pointer`	Um tipo que fornece um ponteiro para um elemento em um `deque`.
`reference`	Um tipo que fornece uma referência a um elemento armazenado em um `deque`.
`reverse_iterator`	Um tipo que fornece um iterador de acesso aleatório que pode ler ou modificar um elemento em um `deque`. O `deque` é visto em ordem inversa.
`size_type`	Um tipo que conta o número de elementos em um `deque`.
`value_type`	Um tipo que representa o tipo de dados armazenados em um `deque`.

Funções

Designação	Descrição
`assign`	Apaga elementos de um `deque` e copia uma nova sequência de elementos para o `deque`de destino.
`at`	Retorna uma referência ao elemento em um local especificado no `deque`.
`back`	Retorna uma referência ao último elemento do `deque`.
`begin`	Retorna um iterador de acesso aleatório endereçando o primeiro elemento no `deque`.
`cbegin`	Retorna um iterador de `const` para o primeiro elemento no `deque`.
`cend`	Retorna um iterador de `const` de acesso aleatório que aponta logo além do final do `deque`.
`clear`	Apaga todos os elementos de um `deque`.
`crbegin`	Retorna um iterador de `const` de acesso aleatório ao primeiro elemento de um `deque` visualizado em ordem inversa.
`crend`	Retorna um iterador de `const` de acesso aleatório ao primeiro elemento de um `deque` visualizado em ordem inversa.
`emplace`	Insere um elemento construído no lugar no `deque` em uma posição especificada.
`emplace_back`	Adiciona um elemento construído no local ao final do `deque`.
`emplace_front`	Adiciona um elemento construído no local ao início do `deque`.
`empty`	Retorna `true` se o `deque` contém zero elementos e `false` se ele contém um ou mais elementos.
`end`	Retorna um iterador de acesso aleatório que aponta logo além do final do `deque`.
`erase`	Remove um elemento ou um intervalo de elementos em um `deque` de posições especificadas.
`front`	Retorna uma referência ao primeiro elemento de um `deque`.
`get_allocator`	Retorna uma cópia do objeto `allocator` que é usado para construir o `deque`.
`insert`	Insere um elemento, vários elementos ou um intervalo de elementos no `deque` em uma posição especificada.
`max_size`	Devolve o comprimento máximo possível do `deque`.
`pop_back`	Apaga o elemento no final do `deque`.
`pop_front`	Apaga o elemento no início do `deque`.
`push_back`	Adiciona um elemento ao final do `deque`.
`push_front`	Adiciona um elemento ao início do `deque`.
`rbegin`	Retorna um iterador de acesso aleatório para o primeiro elemento em um `deque`invertido.
`rend`	Retorna um iterador de acesso aleatório que aponta logo além do último elemento em uma `deque`invertida.
`resize`	Especifica um novo tamanho para um `deque`.
`shrink_to_fit`	Elimina o excesso de capacidade.
`size`	Devolve o número de elementos na `deque`.
`swap`	Troca os elementos de dois `deque`s.

Operadores

Designação	Descrição
`operator[]`	Retorna uma referência ao elemento `deque` em uma posição especificada.
`operator=`	Substitui os elementos do `deque` por uma cópia de outro `deque`.

`allocator_type`

Um tipo que representa a classe alocator para o objeto deque.

typedef Allocator allocator_type;

Comentários

allocator_type é sinônimo do parâmetro de modelo Allocator.

Exemplo

Veja o exemplo para get_allocator.

`assign`

Apaga elementos de um deque e copia um novo conjunto de elementos para o dequede destino.

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

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

void assign(initializer_list<Type> IList);

Parâmetros

First
Posição do primeiro elemento no intervalo de elementos a serem copiados do argumento deque.

Last
Posição do primeiro elemento além do intervalo de elementos a serem copiados do argumento deque.

Count
O número de cópias de um elemento que está sendo inserido no deque.

Val
O valor do elemento que está sendo inserido no deque.

IList
O initializer_list sendo inserido no deque.

Comentários

Depois que todos os elementos existentes no deque de destino forem apagados, assign insere um intervalo especificado de elementos do deque original ou de algum outro deque no dequede destino ou insere cópias de um novo elemento de um valor especificado no dequede destino.

Exemplo

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

Retorna uma referência ao elemento em um local especificado no deque.

reference at(size_type pos);

const_reference at(size_type pos) const;

Parâmetros

pos
O subscrito (ou número da posição) do elemento a ser referenciado no deque.

Valor de retorno

Se pos for maior do que o tamanho do deque, at lançará uma exceção.

Comentários

Se o valor de retorno de at for atribuído a um const_reference, o objeto deque não poderá ser modificado. Se o valor de retorno de at for atribuído a um reference, o objeto deque poderá ser modificado.

Exemplo

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

Retorna uma referência ao último elemento do deque.

reference back();
const_reference back() const;

Valor de retorno

O último elemento do deque. Se o deque estiver vazio, o valor de retorno será indefinido.

Comentários

Se o valor de retorno de back for atribuído a um const_reference, o objeto deque não poderá ser modificado. Se o valor de retorno de back for atribuído a um reference, o objeto deque poderá ser modificado.

Quando compilado usando _ITERATOR_DEBUG_LEVEL definido como 1 ou 2, ocorrerá um erro de tempo de execução se você tentar acessar um elemento em um dequevazio. Consulte de iteradores verificados para obter mais informações.

Exemplo

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

Retorna um iterador endereçando o primeiro elemento no deque.

const_iterator begin() const;
iterator begin();

Valor de retorno

Um iterador de acesso aleatório endereçando o primeiro elemento no deque ou para o local que sucede um dequevazio .

Comentários

Se o valor de retorno de begin for atribuído a um const_iterator, o objeto deque não poderá ser modificado. Se o valor de retorno de begin for atribuído a um iterator, o objeto deque poderá ser modificado.

Exemplo

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

Retorna um iterador const que aborda o primeiro elemento no intervalo.

const_iterator cbegin() const;

Valor de retorno

Um iterador de acesso aleatório const que aponta para o primeiro elemento do intervalo ou para o local logo após o final de um intervalo vazio (para um intervalo vazio, cbegin() == cend()).

Comentários

Com o valor de retorno de cbegin, os elementos no intervalo não podem ser modificados.

Você pode usar essa função de membro no lugar da função de membro begin() para garantir que o valor de retorno seja const_iterator. Normalmente, ele é usado em conjunto com a palavra-chave de dedução de tipo auto, conforme mostrado no exemplo a seguir. No exemplo, considere Container como um recipiente modificável (não const) de qualquer tipo que suporte begin() e cbegin().

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

// i2 is Container<T>::const_iterator

`cend`

Retorna um iterador const que aborda o local logo após o último elemento de um intervalo.

const_iterator cend() const;

Valor de retorno

Um iterador de acesso aleatório que aponta para além do final do intervalo.

Comentários

cend é usado para testar se um iterador passou no final de seu intervalo.

Você pode usar essa função de membro no lugar da função de membro end() para garantir que o valor de retorno seja const_iterator. Normalmente, ele é usado em conjunto com a palavra-chave de dedução de tipo auto, conforme mostrado no exemplo a seguir. No exemplo, considere Container como um recipiente modificável (não const) de qualquer tipo que suporte end() e cend().

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

// i2 is Container<T>::const_iterator

O valor retornado por cend não deve ser desreferenciado.

`clear`

Apaga todos os elementos de um deque.

void clear();

Exemplo

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

Um tipo que fornece um iterador de acesso aleatório que pode acessar e ler um elemento const no deque.

typedef implementation-defined const_iterator;

Comentários

Um tipo const_iterator não pode ser usado para modificar o valor de um elemento.

Exemplo

Veja o exemplo para back.

`const_pointer`

Fornece um ponteiro para um elemento const em um deque.

typedef typename Allocator::const_pointer const_pointer;

Comentários

Um tipo const_pointer não pode ser usado para modificar o valor de um elemento. Um iterator é mais comumente usado para acessar um elemento deque.

`const_reference`

Um tipo que fornece uma referência a um elemento const armazenado em um deque para ler e executar operações const.

typedef typename Allocator::const_reference const_reference;

Comentários

Um tipo const_reference não pode ser usado para modificar o valor de um elemento.

Exemplo

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

Um tipo que fornece um iterador de acesso aleatório que pode ler qualquer elemento const no deque.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Comentários

Um tipo const_reverse_iterator não pode modificar o valor de um elemento e é usado para iterar através do deque inversamente.

Exemplo

Veja o exemplo para rbegin para um exemplo de como declarar e usar um iterador.

`crbegin`

Retorna um iterador de const para o primeiro elemento em um dequeinvertido.

const_reverse_iterator crbegin() const;

Valor de retorno

Um iterador de acesso aleatório reverso const abordando o primeiro elemento em um deque reverso ou abordando o que havia sido o último elemento no dequenão reverso.

Comentários

Com o valor de retorno de crbegin, o objeto deque não pode ser modificado.

Exemplo

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

Retorna um iterador de const que aborda o local que sucede o último elemento em um dequeinvertido.

const_reverse_iterator crend() const;

Valor de retorno

Um const iterador de acesso aleatório reverso que aborda o local que sucede o último elemento em um deque reverso (o local que precedeu o primeiro elemento na dequenão invertida).

Comentários

crend é usado com um deque invertido, assim como array::cend é usado com um deque.

Com o valor de retorno de crend (adequadamente diminuído), o objeto deque não pode ser modificado.

crend pode ser usado para testar se um iterador reverso chegou ao final de sua deque.

O valor retornado por crend não deve ser desreferenciado.

Exemplo

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

Constrói um deque de um tamanho específico, ou com elementos de um valor específico, ou com um alocador específico, ou como uma cópia de todo ou parte de algum outro 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);

Parâmetros

Al
A classe de alocador a ser usada com esse objeto.

Count
O número de elementos na dequeconstruída.

Val
O valor dos elementos na dequeconstruída.

Right
O deque do qual o deque construído deve ser uma cópia.

First
Posição do primeiro elemento na gama de elementos a copiar.

Last
Posição do primeiro elemento para além da gama de elementos a copiar.

IList
O initializer_list a ser copiado.

Comentários

Todos os construtores armazenam um objeto alocador (Al) e inicializam o deque.

Os dois primeiros construtores especificam um dequeinicial vazio; o segundo também especifica o tipo de alocador (_Al) a ser usado.

O terceiro construtor especifica uma repetição de um número especificado (count) de elementos do valor padrão para a classe Type.

O quarto e quinto construtores especificam uma repetição de (Count) elementos de valor val.

O sexto construtor especifica uma cópia do dequeRight.

O sétimo e oitavo construtores copiam o intervalo [First, Last) de um deque.

O sétimo construtor move o dequeRight.

O oitavo construtor copia o conteúdo de um initializer_list.

Nenhum dos construtores realiza realocações provisórias.

Exemplo

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

Um tipo que fornece a diferença entre dois iteradores que se referem a elementos dentro do mesmo deque.

typedef typename Allocator::difference_type difference_type;

Comentários

Um difference_type também pode ser descrito como o número de elementos entre dois ponteiros.

Exemplo

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

Insere um elemento construído no lugar no deque em uma posição especificada.

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

Parâmetros

_Where
A posição no deque onde o primeiro elemento é inserido.

val
O valor do elemento que está sendo inserido no deque.

Valor de retorno

A função retorna um iterador que aponta para a posição onde o novo elemento foi inserido no deque.

Comentários

Qualquer operação de inserção pode ser cara, consulte deque para uma discussão sobre deque desempenho.

Exemplo

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

Adiciona um elemento construído no local ao final do deque.

void emplace_back(Type&& val);

Parâmetros

val
O elemento adicionado ao final do deque.

Exemplo

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

Adiciona um elemento construído no local ao final do deque.

void emplace_front(Type&& val);

Parâmetros

val
O elemento adicionado ao início do deque.

Exemplo

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

Testa se um deque está vazio.

bool empty() const;

Valor de retorno

true se o deque estiver vazio; false se o deque não estiver vazio.

Exemplo

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

Retorna um iterador que aborda o local que sucede o último elemento em um deque.

const_iterator end() const;

iterator end();

Valor de retorno

Um iterador de acesso aleatório que aborda o local que sucede o último elemento em um deque. Se o deque estiver vazio, então deque::end == deque::begin.

Comentários

end é usado para testar se um iterador chegou ao final de sua deque.

Exemplo

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

Remove um elemento ou um intervalo de elementos em um deque de posições especificadas.

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

Parâmetros

_Where
Posição do elemento a retirar do deque.

first
Posição do primeiro elemento retirado do deque.

last
Posição logo após o último elemento removido do deque.

Valor de retorno

Um iterador de acesso aleatório que designa o primeiro elemento restante além de quaisquer elementos removidos, ou um ponteiro para o final do deque se tal elemento não existir.

Comentários

erase nunca lança uma exceção.

Exemplo

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

Retorna uma referência ao primeiro elemento de um deque.

reference front();

const_reference front() const;

Valor de retorno

Se o deque estiver vazio, o retorno será indefinido.

Comentários

Se o valor de retorno de front for atribuído a um const_reference, o objeto deque não poderá ser modificado. Se o valor de retorno de front for atribuído a um reference, o objeto deque poderá ser modificado.

Exemplo

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

Retorna uma cópia do objeto alocador usado para construir o deque.

Allocator get_allocator() const;

Valor de retorno

O alocador utilizado pelo deque.

Comentários

Os alocadores para a classe deque especificam como a classe gerencia o armazenamento. Os alocadores padrão fornecidos com classes de contêiner C++ Standard Library são suficientes para a maioria das necessidades de programação. Escrever e usar sua própria classe de alocador é um tópico C++ avançado.

Exemplo

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

Insere um elemento ou vários elementos ou um intervalo de elementos no deque em uma posição especificada.

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

Parâmetros

Where
A posição na deque de destino onde o primeiro elemento é inserido.

Val
O valor do elemento que está sendo inserido no deque.

Count
O número de elementos inseridos no deque.

First
A posição do primeiro elemento no intervalo de elementos no argumento deque de ser copiada.

Last
A posição do primeiro elemento além do intervalo de elementos no argumento deque ser copiada.

IList
A initializer_list de elementos a inserir.

Valor de retorno

As duas primeiras funções insert retornam um iterador que aponta para a posição onde o novo elemento foi inserido no deque.

Comentários

Qualquer operação de inserção pode ser cara.

`iterator`

Um tipo que fornece um iterador de acesso aleatório que pode ler ou modificar qualquer elemento em um deque.

typedef implementation-defined iterator;

Comentários

Um tipo iterator pode ser usado para modificar o valor de um elemento.

Exemplo

Veja o exemplo para begin.

`max_size`

Devolve o comprimento máximo da deque.

size_type max_size() const;

Valor de retorno

O comprimento máximo possível do deque.

Exemplo

// 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[]`

Retorna uma referência ao elemento deque em uma posição especificada.

reference operator[](size_type pos);

const_reference operator[](size_type pos) const;

Parâmetros

pos
A posição do elemento deque a ser referenciado.

Valor de retorno

Uma referência ao elemento cuja posição é especificada no argumento. Se a posição especificada for maior do que o tamanho do deque, o resultado será indefinido.

Comentários

Se o valor de retorno de operator[] for atribuído a um const_reference, o objeto deque não poderá ser modificado. Se o valor de retorno de operator[] for atribuído a um reference, o objeto deque poderá ser modificado.

Quando compilado usando _ITERATOR_DEBUG_LEVEL definido como 1 ou 2, ocorrerá um erro de tempo de execução se você tentar acessar um elemento fora dos limites do deque. Consulte de iteradores verificados para obter mais informações.

Exemplo

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

Substitui os elementos deste deque usando os elementos de outro deque.

deque& operator=(const deque& right);

deque& operator=(deque&& right);

Parâmetros

right
O deque que fornece o novo conteúdo.

Comentários

A primeira substituição copia elementos para este deque de right, a origem da atribuição. A segunda substituição move elementos para este deque de right.

Os elementos contidos neste deque antes da execução do operador são removidos.

Exemplo

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

Fornece um ponteiro para um elemento em um deque.

typedef typename Allocator::pointer pointer;

Comentários

Um tipo pointer pode ser usado para modificar o valor de um elemento. Um iterator é mais comumente usado para acessar um elemento deque.

`pop_back`

Exclui o elemento no final do deque.

void pop_back();

Comentários

O último elemento não deve estar vazio. pop_back nunca lança uma exceção.

Exemplo

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

Exclui o elemento no início do deque.

void pop_front();

Comentários

O primeiro elemento não deve estar vazio. pop_front nunca lança uma exceção.

Exemplo

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

Adiciona um elemento ao final do deque.

void push_back(const Type& val);

void push_back(Type&& val);

Parâmetros

val
O elemento adicionado ao final do deque.

Comentários

Se uma exceção for lançada, a deque será deixada inalterada e a exceção será relançada.

`push_front`

Adiciona um elemento ao início do deque.

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

Parâmetros

val
O elemento adicionado ao início do deque.

Comentários

Se uma exceção for lançada, a deque será deixada inalterada e a exceção será relançada.

Exemplo

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

Retorna um iterador para o primeiro elemento em um dequeinvertido.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valor de retorno

Um iterador de acesso aleatório reverso abordando o primeiro elemento em um deque reverso ou abordando o que havia sido o último elemento no dequenão revertido .

Comentários

rbegin é usado com um deque invertido, assim como begin é usado com um deque.

Se o valor de retorno de rbegin for atribuído a um const_reverse_iterator, o objeto deque não poderá ser modificado. Se o valor de retorno de rbegin for atribuído a um reverse_iterator, o objeto deque poderá ser modificado.

rbegin pode ser usado para iterar através de um deque para trás.

Exemplo

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

Um tipo que fornece uma referência a um elemento armazenado em um deque.

typedef typename Allocator::reference reference;

Exemplo

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

Retorna um iterador que aborda o local que sucede o último elemento em uma dequeinvertida.

const_reverse_iterator rend() const;

reverse_iterator rend();

Valor de retorno

Um iterador de acesso aleatório reverso que aborda o local que sucede o último elemento em um deque reverso (o local que precedeu o primeiro elemento na dequenão invertida).

Comentários

rend é usado com um deque invertido, assim como end é usado com um deque.

Se o valor de retorno de rend for atribuído a um const_reverse_iterator, o objeto deque não poderá ser modificado. Se o valor de retorno de rend for atribuído a um reverse_iterator, o objeto deque poderá ser modificado.

rend pode ser usado para testar se um iterador reverso atingiu o final de sua deque.

O valor retornado por rend não deve ser desreferenciado.

Exemplo

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

Especifica um novo tamanho para um deque.

void resize(size_type _Newsize);

void resize(size_type _Newsize, Type val);

Parâmetros

_Newsize
O novo tamanho do deque.

val
O valor dos novos elementos a serem adicionados ao deque se o novo tamanho for maior que o tamanho original. Se o valor for omitido, os novos elementos receberão o valor padrão para a classe.

Comentários

Se o size do dequefor menor que _Newsize, os elementos serão adicionados ao deque até que ele atinja o tamanho _Newsize.

Se o size do dequefor maior que _Newsize, os elementos mais próximos do final do deque serão excluídos até que o deque atinja o tamanho _Newsize.

Se o tamanho atual do deque for o mesmo que _Newsize, nenhuma ação será tomada.

size reflete o tamanho atual do deque.

Exemplo

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

Um tipo que fornece um iterador de acesso aleatório que pode ler ou modificar um elemento em um dequereverso.

typedef std::reverse_iterator<iterator> reverse_iterator;

Comentários

Um tipo reverse_iterator é usado para iterar através do deque.

Exemplo

Veja o exemplo para rbegin.

`shrink_to_fit`

Elimina o excesso de capacidade.

void shrink_to_fit();

Comentários

Não há uma maneira portátil de determinar se shrink_to_fit reduz o armazenamento usado por um deque.

Exemplo

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

Devolve o número de elementos na deque.

size_type size() const;

Valor de retorno

O comprimento atual do deque.

Exemplo

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

Um tipo que conta o número de elementos em um deque.

typedef typename Allocator::size_type size_type;

Exemplo

Veja o exemplo para size.

`swap`

Troca os elementos de dois 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);

Parâmetros

right
O deque que fornece os elementos a trocar, ou o deque cujos elementos devem ser trocados com os do dequeleft.

left
Um deque cujos elementos devem ser trocados com os do dequeright.

Exemplo

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

Um tipo que representa o tipo de dados armazenados em um deque.

typedef typename Allocator::value_type value_type;

Comentários

value_type é sinônimo do parâmetro de modelo Type.

Exemplo

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

Ver também

segurança de threads na biblioteca padrão C++
de referência da biblioteca padrão C++

Partilhar via

deque Classe

Sintaxe

Parâmetros

Comentários

Membros

Construtores

Typedefs

Funções

Operadores

allocator_type

Comentários

Exemplo

assign

Parâmetros

Comentários

Exemplo

at

Parâmetros

Valor de retorno

Comentários

Exemplo

back

Valor de retorno

Comentários

Exemplo

begin

Valor de retorno

Comentários

Exemplo

cbegin

Valor de retorno

Comentários

cend

Valor de retorno

Comentários

clear

Exemplo

const_iterator

Comentários

Exemplo

const_pointer

Comentários

const_reference

Comentários

Exemplo

const_reverse_iterator

Comentários

Exemplo

crbegin

Valor de retorno

Comentários

Exemplo

crend

Valor de retorno

Comentários

Exemplo

deque

Parâmetros

Comentários

Exemplo

difference_type

Comentários

Exemplo

emplace

Parâmetros

Valor de retorno

Comentários

Exemplo

emplace_back

Parâmetros

Exemplo

emplace_front

Parâmetros

Exemplo

empty

Valor de retorno

Exemplo

end

Valor de retorno

`deque` Classe

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