Clase `deque`

Artículo
04/03/2023

Organiza los elementos de un tipo determinado en una organización lineal y, como un vector, permite un acceso aleatorio rápido a cualquier elemento y, una inserción y eliminación eficaces al final del contenedor. Sin embargo, a diferencia de un vector, la clase deque también admite la inserción y la eliminación eficaces al principio del contenedor.

Sintaxis

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

Parámetros

Type
Tipo de datos de elementos que se va a almacenar en la deque.

Allocator
Tipo que representa el objeto asignador almacenado que encapsula los detalles acerca de la asignación y desasignación de memoria de deque. Este argumento es opcional y el valor predeterminado es allocator<Type>.

Comentarios

En general, la elección del tipo de contenedor se debe tomar según el tipo de búsqueda y de inserción que necesite la aplicación. Vectors deben ser el contenedor preferido para administrar una secuencia cuando escasee el acceso aleatorio a algún elemento y solo sea necesario realizar inserciones o eliminaciones de elementos al final de una secuencia. El rendimiento del contenedor de lista es superior cuando las inserciones y eliminaciones eficaces (en tiempo constante) en cualquier ubicación dentro de la secuencia son importantes. Esas operaciones en medio de la secuencia requieren copias y asignaciones de elementos proporcionales al número de elementos de la secuencia (tiempo lineal).

La reasignación Deque se realiza cuando una función miembro debe insertar o borrar elementos de la secuencia:

Si un elemento se inserta en una secuencia vacía, o si un elemento se borra para dejar una secuencia vacía, los iteradores anteriores devueltos por begin y end dejan de ser válidos.
Si se inserta un elemento en la primera posición del deque, todos los iteradores, pero ninguna referencia, que designan elementos existentes dejan de ser válidos.
Si se inserta un elemento al final del deque, end y todos los iteradores, pero ninguna referencia, que designan elementos existentes dejan de ser válidos.
Si se borra un elemento al principio del deque, solo el iterador y las referencias al elemento borrado dejan de ser válidos.
Si se borra el último elemento del final del deque, solo el iterador al elemento final y las referencias al elemento borrado dejan de ser válidos.

De lo contrario, al insertar o borrar un elemento se invalidan todos los iteradores y referencias.

Miembros

Constructores

Nombre Descripción

deque Construye un objeto deque. Se proporcionan varios constructores para configurar el contenido del nuevo deque de diferentes maneras: vacío; cargado con un número especificado de elementos vacíos; contenido movido o copiado de otro deque; contenido copiado o movido mediante un iterador; y un elemento copiado en las deque count horas. Algunos de los constructores permiten usar un allocator personalizado para crear elementos.

Nombre	Descripción
`deque`	Construye un objeto `deque`. Se proporcionan varios constructores para configurar el contenido del nuevo `deque` de diferentes maneras: vacío; cargado con un número especificado de elementos vacíos; contenido movido o copiado de otro `deque`; contenido copiado o movido mediante un iterador; y un elemento copiado en las `deque` `count` horas. Algunos de los constructores permiten usar un `allocator` personalizado para crear elementos.

Typedefs

Nombre	Descripción
`allocator_type`	Tipo que representa la clase `allocator` para el objeto `deque`.
`const_iterator`	Tipo que proporciona un iterador de acceso aleatorio que puede obtener acceso a elementos de `deque` como `const` y leerlos.
`const_pointer`	Tipo que proporciona un puntero a un elemento de `deque` como `const`.
`const_reference`	Tipo que proporciona una referencia a un elemento de `deque` para leer y otras operaciones como `const`.
`const_reverse_iterator`	Tipo que proporciona un iterador de acceso aleatorio que puede obtener acceso a elementos del `deque` como `const` y leerlos. El `deque` se ve en orden inverso. Para obtener más información, consulte la Class `reverse_iterator`.
`difference_type`	Tipo que proporciona la diferencia entre dos iteradores de acceso aleatorio que hacen referencia a elementos del mismo `deque`.
`iterator`	Tipo que proporciona un iterador de acceso aleatorio que puede leer o modificar cualquier elemento de `deque`.
`pointer`	Tipo que proporciona un puntero a un elemento de `deque`.
`reference`	Tipo que proporciona una referencia a un elemento almacenado en un `deque`.
`reverse_iterator`	Tipo que proporciona un iterador de acceso aleatorio que puede leer o modificar un elemento de `deque`. El `deque` se ve en orden inverso.
`size_type`	Tipo que cuenta el número de elementos de un `deque`.
`value_type`	Tipo que representa el tipo de datos almacenados en un `deque`.

Funciones

Nombre	Descripción
`assign`	Borra elementos de un `deque` y copia una nueva secuencia de elementos al `deque` de destino.
`at`	Devuelve una referencia al elemento situado en una ubicación especificada del `deque`.
`back`	Devuelve una referencia al último elemento del `deque`.
`begin`	Devuelve un iterador de acceso aleatorio que direcciona el primer elemento del `deque`.
`cbegin`	Un iterador `const` al primer elemento del rango en el `deque`.
`cend`	Devuelve un iterador `const` de acceso aleatorio que apunta justo después del final del `deque`.
`clear`	Borra todos los elementos de un `deque`.
`crbegin`	Devuelve un iterador `const` constante de acceso aleatorio al primer elemento de `deque` que se ve en orden inverso.
`crend`	Devuelve un iterador `const` constante de acceso aleatorio al primer elemento de `deque` que se ve en orden inverso.
`emplace`	Inserta en una posición especificada del `deque` un elemento construido en contexto.
`emplace_back`	Agrega un elemento construido en contexto al final del `deque`.
`emplace_front`	Agrega un elemento construido en contexto al principio del `deque`.
`empty`	Devuelve `true` si el `deque` contiene cero elementos y `false` si contiene uno o más elementos.
`end`	Devuelve un iterador de acceso aleatorio que apunta justo después del final del `deque`.
`erase`	Quita un elemento o un intervalo de elementos de un `deque` de las posiciones especificadas.
`front`	Devuelve una referencia al primer elemento de `deque`.
`get_allocator`	Devuelve una copia del objeto `allocator` utilizado para construir el `deque`.
`insert`	Inserta un elemento, varios elementos o un intervalo de elementos en una posición especificada del `deque`.
`max_size`	Devuelve la longitud máxima posible del `deque`.
`pop_back`	Borra el elemento situado al final del `deque`.
`pop_front`	Borra el elemento situado al principio del `deque`.
`push_back`	Agrega un elemento al final del `deque`.
`push_front`	Agrega un elemento al principio del `deque`.
`rbegin`	Devuelve un iterador de acceso aleatorio al primer elemento de `deque` invertido.
`rend`	Devuelve un iterador de acceso aleatorio que apunta justo detrás del último elemento de `deque` invertido.
`resize`	Especifica un nuevo tamaño para un `deque`.
`shrink_to_fit`	Descarta el exceso de capacidad.
`size`	Devuelve el número de elementos de `deque`.
`swap`	Intercambia los elementos de dos `deque`.

Operadores

Nombre	Descripción
`operator[]`	Devuelve una referencia al elemento del `deque` en una posición especificada.
`operator=`	Reemplaza los elementos del `deque` con una copia de otro `deque`.

`allocator_type`

Tipo que representa la clase de asignador del objeto deque.

typedef Allocator allocator_type;

Comentarios

allocator_type es un sinónimo del parámetro de plantilla Allocator.

Ejemplo

Vea el ejemplo de get_allocator.

`assign`

Borra elementos de un deque y copia un nuevo conjunto de elementos al deque de 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
Posición del primer elemento en el intervalo de elementos que se va a copiar de la lista de argumentos deque.

Last
Posición del primer elemento que se encuentra más allá del intervalo de elementos que se va a copiar del argumento deque.

Count
Número de copias de un elemento que se va a insertar en la deque.

Val
Valor del elemento insertado en el deque.

IList
initializer_list insertado en deque.

Comentarios

Después de borrar los elementos existentes en el deque de destino, assign inserta un intervalo especificado de elementos del deque original o de otro deque en el deque de destino, o inserta copias de un nuevo elemento de un valor especificado en el deque de destino.

Ejemplo

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

Devuelve una referencia al elemento situado en una ubicación especificada del deque.

reference at(size_type pos);

const_reference at(size_type pos) const;

Parámetros

pos
Subíndice (o número de posición) del elemento al que se va a hacer referencia en el deque.

Valor devuelto

Si pos es mayor que el tamaño del deque, at inicia una excepción.

Comentarios

Si el valor devuelto de at se asigna a un const_reference, deque no se puede modificar. Si el valor devuelto de at se asigna a un reference, deque sí se puede modificar.

Ejemplo

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

Devuelve una referencia al último elemento del deque.

reference back();
const_reference back() const;

Valor devuelto

El último elemento de deque. Si deque está vacío, el valor devuelto es indefinido.

Comentarios

Si el valor devuelto de back se asigna a un const_reference, deque no se puede modificar. Si el valor devuelto de back se asigna a un reference, deque sí se puede modificar.

Al compilar con _ITERATOR_DEBUG_LEVEL definido como 1 o 2, se producirá un error en tiempo de ejecución si intenta obtener acceso a un elemento de una deque vacía. Vea Iteradores comprobados para obtener más información.

Ejemplo

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

Devuelve un iterador que direcciona el primer elemento del deque.

const_iterator begin() const;
iterator begin();

Valor devuelto

Un iterador de acceso aleatorio que se dirige al primer elemento del deque o a la ubicación que sigue a un deque vacío.

Comentarios

Si el valor devuelto de begin se asigna a un const_iterator, deque no se puede modificar. Si el valor devuelto de begin se asigna a un iterator, deque sí se puede modificar.

Ejemplo

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

Devuelve un iterador const que direcciona el primer elemento del intervalo.

const_iterator cbegin() const;

Valor devuelto

Iterador const de acceso aleatorio que apunta al primer elemento del intervalo o la ubicación situada más allá del final de un intervalo vacío (para un intervalo vacío, cbegin() == cend()).

Comentarios

Con el valor devuelto de cbegin, los elementos del intervalo no se pueden modificar.

Se puede usar esta función miembro en lugar de la función miembro begin() para garantizar que el valor devuelto es const_iterator. Normalmente, se usa junto con la palabra clave de deducción de tipos auto, como se muestra en el ejemplo siguiente. En el ejemplo se considera que Container es un contenedor modificable (distinto de const) de cualquier naturaleza que admite begin() y cbegin().

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

// i2 is Container<T>::const_iterator

`cend`

Devuelve un iterador const que direcciona la ubicación situada más allá del último elemento de un intervalo.

const_iterator cend() const;

Valor devuelto

Iterador de acceso aleatorio que apunta justo después del final del intervalo.

Comentarios

cend se usa para probar si un iterador ha sobrepasado el final de su intervalo.

Se puede usar esta función miembro en lugar de la función miembro end() para garantizar que el valor devuelto es const_iterator. Normalmente, se usa junto con la palabra clave de deducción de tipos auto, como se muestra en el ejemplo siguiente. En el ejemplo se considera que Container es un contenedor modificable (distinto de const) de cualquier naturaleza que admite end() y cend().

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

// i2 is Container<T>::const_iterator

El valor devuelto por cend no se debe desreferenciar.

`clear`

Borra todos los elementos de un deque.

void clear();

Ejemplo

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

Tipo que proporciona un iterador de acceso aleatorio que puede acceder a un elemento const de la deque y leerlo.

typedef implementation-defined const_iterator;

Comentarios

Un tipo const_iterator no se puede utilizar para modificar el valor de un elemento.

Ejemplo

Vea el ejemplo de back.

`const_pointer`

Proporciona un puntero a un elemento const de una deque.

typedef typename Allocator::const_pointer const_pointer;

Comentarios

Un tipo const_pointer no se puede utilizar para modificar el valor de un elemento. Un iterator se usa normalmente para tener acceso a un elemento deque.

`const_reference`

Tipo que proporciona una referencia a un elemento const almacenado en un deque para leer y realizar operaciones const.

typedef typename Allocator::const_reference const_reference;

Comentarios

Un tipo const_reference no se puede utilizar para modificar el valor de un elemento.

Ejemplo

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

Tipo que proporciona un iterador de acceso aleatorio que puede leer cualquier elemento const en el deque.

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Comentarios

Un tipo const_reverse_iterator no puede modificar el valor de un elemento y se usa para iterar por deque en orden inverso.

Ejemplo

Vea el ejemplo de rbegin para obtener un ejemplo de cómo declarar y usar iterator.

`crbegin`

Devuelve un iterador const al primer elemento en un deque invertido.

const_reverse_iterator crbegin() const;

Valor devuelto

Un iterador inverso const de acceso aleatorio que se dirige al primer elemento de un deque inverso o al que fue el último elemento del deque sin invertir.

Comentarios

Con el valor devuelto de crbegin, el objeto deque no se puede modificar.

Ejemplo

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

Devuelve un iterador const que direcciona la ubicación que sigue al último elemento de un deque invertido.

const_reverse_iterator crend() const;

Valor devuelto

Un iterador inverso const de acceso aleatorio que se dirige a la ubicación siguiente al último elemento de un deque invertido (la ubicación que había precedido al primer elemento del deque sin invertir).

Comentarios

crend se usa con un deque invertido igual que array::cend se usa con un deque.

Con el valor devuelto de crend (adecuadamente reducido), el objeto deque no se puede modificar.

Se puede utilizar crend para comprobar si un iterador inverso llegó al final de su deque.

El valor devuelto por crend no se debe desreferenciar.

Ejemplo

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

Construye una deque de un tamaño específico o con elementos de un valor específico o con un asignador específico o como una copia de todo o de parte de alguna otra 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
La clase de asignador que se usa con este objeto.

Count
Número de elementos del deque construido.

Val
Valor de los elementos del deque construido.

Right
deque del que el deque construido va a ser una copia.

First
Posición del primer elemento en el intervalo de elementos que se va a copiar.

Last
Posición del primer elemento más allá del intervalo de elementos que se va a copiar.

IList
El initializer_list que se va a copiar.

Comentarios

Todos los constructores almacenan un objeto de asignador (Al) e inicializan la deque.

Los dos primeros constructores especifican un deque inicial vacío y el segundo especifica también el tipo de asignador (_Al) que se va a usar.

El tercer constructor especifica una repetición de un número especificado (count) de elementos del valor predeterminado para la clase Type.

Los constructores cuarto y quinto especifican una repetición de elementos (Count) de valor val.

El sexto constructor especifica una copia de .deque Right

Los constructores séptimo y octavo copian el intervalo [First, Last) de un deque.

El séptimo constructor mueve .deque Right

El octavo constructor copia el contenido de una initializer_list.

Ninguno de los constructores realiza ninguna reasignación provisional.

Ejemplo

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

Tipo que proporciona la diferencia entre dos iteradores que hacen referencia a elementos de la misma clase deque.

typedef typename Allocator::difference_type difference_type;

Comentarios

Un difference_type también se puede describir como el número de elementos entre dos punteros.

Ejemplo

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

Inserta en una posición especificada del deque un elemento construido en contexto.

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

Parámetros

_Where
Posición del deque en la que se inserta el primer elemento.

val
Valor del elemento insertado en el deque.

Valor devuelto

La función devuelve un iterador que apunta a la posición en la que se insertó el nuevo elemento en el deque.

Comentarios

Las operaciones de inserción pueden ser costosas, vea deque para obtener una explicación del rendimiento de un deque.

Ejemplo

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

Agrega un elemento construido en contexto al final del deque.

void emplace_back(Type&& val);

Parámetros

val
El elemento que se agrega al final de la deque.

Ejemplo

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

Agrega un elemento construido en contexto al final del deque.

void emplace_front(Type&& val);

Parámetros

val
El elemento que se agrega al principio de deque.

Ejemplo

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

Comprueba si un deque está vacío.

bool empty() const;

Valor devuelto

true si deque está vacío; false si deque no está vacío.

Ejemplo

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

Devuelve un iterador que direcciona la ubicación que sigue al último elemento de deque.

const_iterator end() const;

iterator end();

Valor devuelto

Un iterador de acceso aleatorio que se dirige a la ubicación que sigue al último elemento de un deque. Si el deque está vacío, deque::end == deque::begin.

Comentarios

end se usa para comprobar si un iterador ha llegado al final de su deque.

Ejemplo

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

Quita un elemento o un intervalo de elementos de un deque de las posiciones especificadas.

iterator erase(iterator _Where);

iterator erase(iterator first, iterator last);

Parámetros

_Where
Posición del elemento que se quitará de deque.

first
Posición del primer elemento que se quitará de deque.

last
Posición inmediatamente siguiente a la del último elemento que se quitará de deque.

Valor devuelto

Un iterador de acceso aleatorio que designa el primer elemento restante después de los elementos quitados o, si no hay ningún elemento después, un puntero al final del deque.

Comentarios

erase nunca inicia una excepción.

Ejemplo

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

Devuelve una referencia al primer elemento de deque.

reference front();

const_reference front() const;

Valor devuelto

Si el deque está vacío, el valor devuelto es indefinido.

Comentarios

Si el valor devuelto de front se asigna a un const_reference, deque no se puede modificar. Si el valor devuelto de front se asigna a un reference, deque sí se puede modificar.

Ejemplo

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

Devuelve una copia del objeto de asignador usado para construir deque.

Allocator get_allocator() const;

Valor devuelto

Asignador usado por deque.

Comentarios

Los asignadores de la clase deque especifican la forma en que la clase administra el almacenamiento. Los asignadores predeterminados proporcionados con las clases contenedoras de la biblioteca estándar de C++ son suficientes para la mayoría de las necesidades de programación. La escritura y el uso de sus propias clases de asignador son temas avanzados de C++.

Ejemplo

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

Inserta un elemento, varios elementos o un intervalo de elementos en el deque en una posición 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
La posición de la clase deque de destino donde se inserta el primer elemento.

Val
Valor del elemento insertado en el deque.

Count
Número de elementos que se van a insertar en la deque.

First
Posición del primer elemento en el intervalo de elementos de la deque de argumentos que se va a copiar.

Last
Posición del primer elemento más allá del intervalo de elementos de la deque de argumentos que se va a copiar.

IList
El initializer_list de elementos que se van a insertar.

Valor devuelto

Las dos primeras funciones insert devuelven un iterador que apunta a la posición donde se insertó el nuevo elemento en la deque.

Comentarios

Las operaciones de inserción pueden ser muy costosas.

`iterator`

Tipo que proporciona un iterador de acceso aleatorio que puede leer o modificar cualquier elemento de deque.

typedef implementation-defined iterator;

Comentarios

Se puede usar un tipo iterator para modificar el valor de un elemento.

Ejemplo

Vea el ejemplo de begin.

`max_size`

Devuelve la longitud máxima del deque.

size_type max_size() const;

Valor devuelto

Longitud máxima posible de deque.

Ejemplo

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

Devuelve una referencia al elemento del deque en una posición especificada.

reference operator[](size_type pos);

const_reference operator[](size_type pos) const;

Parámetros

pos
La posición del elemento deque al que se va a hacer referencia.

Valor devuelto

Una referencia al elemento cuya posición se especifica en el argumento. Si la posición especificada es mayor que el tamaño del deque, el resultado no está definido.

Comentarios

Si el valor devuelto de operator[] se asigna a un const_reference, deque no se puede modificar. Si el valor devuelto de operator[] se asigna a un reference, deque sí se puede modificar.

Al compilar con _ITERATOR_DEBUG_LEVEL definido como 1 o 2, se produce un error de tiempo de ejecución si intenta tener acceso a un elemento fuera de los límites deque. Vea Iteradores comprobados para obtener más información.

Ejemplo

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

Reemplaza los elementos de este deque con los elementos de otro deque.

deque& operator=(const deque& right);

deque& operator=(deque&& right);

Parámetros

right
deque que proporciona el nuevo contenido.

Comentarios

La primera invalidación copia elementos en este deque desde right, el origen de la asignación. La segunda invalidación mueve elementos a este deque desde right.

Se quitan los elementos contenidos en este deque antes de que se ejecute el operador.

Ejemplo

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

Proporciona un puntero a un elemento de un deque.

typedef typename Allocator::pointer pointer;

Comentarios

Se puede usar un tipo pointer para modificar el valor de un elemento. Un iterator se usa normalmente para tener acceso a un elemento deque.

`pop_back`

Elimina el elemento situado al final del deque.

void pop_back();

Comentarios

El último elemento no debe estar vacío. pop_back nunca inicia una excepción.

Ejemplo

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

Elimina el elemento situado al principio del deque.

void pop_front();

Comentarios

El primer elemento no debe estar vacío. pop_front nunca inicia una excepción.

Ejemplo

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

Agrega un elemento al final del deque.

void push_back(const Type& val);

void push_back(Type&& val);

Parámetros

val
El elemento que se agrega al final de la deque.

Comentarios

Si se lanza una excepción, la deque se deja sin modificar y se vuelve a lanzar la excepción.

`push_front`

Agrega un elemento al principio del deque.

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

Parámetros

val
El elemento que se agrega al principio de deque.

Comentarios

Si se lanza una excepción, la deque se deja sin modificar y se vuelve a lanzar la excepción.

Ejemplo

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

Devuelve un iterador al primer elemento en un deque inverso.

const_reverse_iterator rbegin() const;

reverse_iterator rbegin();

Valor devuelto

Un iterador inverso de acceso aleatorio que se dirige al primer elemento de un deque inverso o al que fue el último elemento del deque sin invertir.

Comentarios

rbegin se usa con un deque invertido igual que begin se usa con un deque.

Si el valor devuelto de rbegin se asigna a un const_reverse_iterator, deque no se puede modificar. Si el valor devuelto de rbegin se asigna a un reverse_iterator, deque sí se puede modificar.

rbegin puede usarse para iterar un objeto deque hacia atrás.

Ejemplo

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

Tipo que proporciona una referencia a un elemento almacenado en un deque.

typedef typename Allocator::reference reference;

Ejemplo

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

Devuelve un iterador que direcciona la ubicación que sigue al último elemento de deque invertido.

const_reverse_iterator rend() const;

reverse_iterator rend();

Valor devuelto

Un iterador inverso de acceso aleatorio que se dirige a la ubicación siguiente al último elemento de un deque invertido (la ubicación que había precedido al primer elemento del deque sin invertir).

Comentarios

rend se usa con un deque invertido igual que end se usa con un deque.

Si el valor devuelto de rend se asigna a un const_reverse_iterator, deque no se puede modificar. Si el valor devuelto de rend se asigna a un reverse_iterator, deque sí se puede modificar.

rend se puede usar para comprobar si un iterador inverso ha llegado al final de deque.

El valor devuelto por rend no se debe desreferenciar.

Ejemplo

// 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 un nuevo tamaño para un deque.

void resize(size_type _Newsize);

void resize(size_type _Newsize, Type val);

Parámetros

_Newsize
El nuevo tamaño de deque.

val
Valor de los nuevos elementos que se agregarán a la deque si el nuevo tamaño es mayor que el tamaño original. Si el valor se omite, a los nuevos elementos se les asigna el valor predeterminado para la clase.

Comentarios

Si el size del deque es inferior a _Newsize, los elementos se añaden al deque hasta que alcanza el tamaño _Newsize.

Si el deque de size es mayor que _Newsize, los elementos más cercanos al final del deque se eliminan hasta que el deque alcanza el tamaño _Newsize.

Si el tamaño actual de la deque es el mismo que _Newsize, no se toma ninguna acción.

size refleja el tamaño actual de la deque.

Ejemplo

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

Tipo que proporciona un iterador de acceso aleatorio que puede leer o modificar un elemento de un deque invertido.

typedef std::reverse_iterator<iterator> reverse_iterator;

Comentarios

Los tipos reverse_iterator se utilizan para procesar una iteración en deque.

Ejemplo

Vea el ejemplo de rbegin.

`shrink_to_fit`

Descarta el exceso de capacidad.

void shrink_to_fit();

Comentarios

No hay ninguna manera portátil de determinar si shrink_to_fit reduce el almacenamiento usado por un deque.

Ejemplo

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

Devuelve el número de elementos de deque.

size_type size() const;

Valor devuelto

Longitud actual de deque.

Ejemplo

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

Tipo que cuenta el número de elementos de un deque.

typedef typename Allocator::size_type size_type;

Ejemplo

Vea el ejemplo de size.

`swap`

Intercambia los elementos de dos 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
deque que proporciona los elementos que se van a intercambiar o cuyos deque elementos se van a intercambiar con los de deque left.

left
deque cuyos elementos se van a intercambiar con los de .deque right

Ejemplo

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

Tipo que representa el tipo de datos almacenados en un deque.

typedef typename Allocator::value_type value_type;

Comentarios

value_type es un sinónimo del parámetro de plantilla Type.

Ejemplo

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

Vea también

Seguridad para subprocesos en la biblioteca estándar de C++
Referencia de biblioteca estándar de C++

Compartir a través de

Clase deque

Sintaxis

Parámetros

Comentarios

Miembros

Constructores

Typedefs

Funciones

Operadores

allocator_type

Comentarios

Ejemplo

assign

Parámetros

Comentarios

Ejemplo

at

Parámetros

Valor devuelto

Comentarios

Ejemplo

back

Valor devuelto

Comentarios

Ejemplo

begin

Valor devuelto

Comentarios

Ejemplo

cbegin

Valor devuelto

Comentarios

cend

Valor devuelto

Comentarios

clear

Ejemplo

const_iterator

Comentarios

Ejemplo

const_pointer

Comentarios

const_reference

Comentarios

Ejemplo

const_reverse_iterator

Comentarios

Ejemplo

crbegin

Valor devuelto

Comentarios

Ejemplo

crend

Valor devuelto

Comentarios

Ejemplo

deque

Parámetros

Comentarios

Ejemplo

difference_type

Comentarios

Ejemplo

emplace

Parámetros

Valor devuelto

Comentarios

Ejemplo

emplace_back

Parámetros

Ejemplo

emplace_front

Parámetros

Ejemplo

empty

Valor devuelto

Ejemplo

end

Valor devuelto

Clase `deque`

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