Namespaces
Variants

std:: deque

From cppreference.net
Definido en el encabezado <deque>
template <

class T,
class Allocator = std:: allocator < T >

> class deque ;
(1)
namespace pmr {

template < class T >
using deque = std :: deque < T, std:: pmr :: polymorphic_allocator < T >> ;

}
(2) (desde C++17)

std::deque (cola de doble extremo) es un contenedor de secuencia indexado que permite una inserción y eliminación rápidas tanto al principio como al final. Además, la inserción y eliminación en cualquier extremo de un deque nunca invalida punteros o referencias al resto de los elementos.

A diferencia de std::vector , los elementos de un deque no se almacenan de forma contigua: las implementaciones típicas utilizan una secuencia de arrays de tamaño fijo asignados individualmente, con contabilidad adicional, lo que significa que el acceso indexado a deque debe realizar dos desreferencias de puntero, en comparación con el acceso indexado de vector que realiza solo una.

El almacenamiento de un deque se expande y contrae automáticamente según sea necesario. La expansión de un deque es más económica que la expansión de un std::vector porque no implica la copia de los elementos existentes a una nueva ubicación de memoria. Por otro lado, los deques típicamente tienen un alto costo mínimo de memoria; un deque que contiene solo un elemento debe asignar su arreglo interno completo (por ejemplo, 8 veces el tamaño del objeto en libstdc++ de 64 bits; 16 veces el tamaño del objeto o 4096 bytes, lo que sea mayor, en libc++ de 64 bits).

La complejidad (eficiencia) de las operaciones comunes en deques es la siguiente:

  • Acceso aleatorio - constante O(1) .
  • Inserción o eliminación de elementos al final o al principio - constante O(1) .
  • Inserción o eliminación de elementos - lineal O(n) .

std::deque cumple con los requisitos de Container , AllocatorAwareContainer , SequenceContainer y ReversibleContainer .

Todas las funciones miembro de std::deque son constexpr : es posible crear y utilizar objetos std::deque en la evaluación de una expresión constante.

Sin embargo, std::deque generalmente no puede ser constexpr , porque cualquier almacenamiento asignado dinámicamente debe liberarse en la misma evaluación de la expresión constante.

(desde C++26)

Contenidos

Parámetros de plantilla

T - El tipo de los elementos.
T debe cumplir con los requisitos de CopyAssignable y CopyConstructible . (hasta C++11)
Los requisitos que se imponen sobre los elementos dependen de las operaciones reales realizadas en el contenedor. Generalmente, se requiere que el tipo de elemento sea un tipo completo y cumpla con los requisitos de Erasable , pero muchas funciones miembro imponen requisitos más estrictos. (desde C++11)

Allocator - Un asignador que se utiliza para adquirir/liberar memoria y para construir/destruir los elementos en esa memoria. El tipo debe cumplir con los requisitos de Allocator . El comportamiento es indefinido (hasta C++20) El programa está mal formado (desde C++20) si Allocator::value_type no es el mismo que T .

Invalidación de iteradores

Operaciones Invalidados
Todas las operaciones de solo lectura. Nunca.
swap , std::swap El iterador past-the-end puede ser invalidado (definido por la implementación).
shrink_to_fit , clear , insert ,
emplace , push_front , push_back ,
emplace_front , emplace_back
Siempre.
erase Si se borra al inicio - solo los elementos borrados.

Si se borra al final - solo los elementos borrados y el iterador past-the-end.
En otro caso - todos los iteradores son invalidados.

No está especificado cuándo se invalida el iterador past-the-end.

(until C++11)

El iterador past-the-end también se invalida a menos que los elementos
borrados estén al inicio del contenedor y el último
elemento no sea borrado.

(since C++11)
resize Si el nuevo tamaño es menor que el anterior - solo los elementos borrados y el
iterador past-the-end.

Si el nuevo tamaño es mayor que el anterior - todos los iteradores son invalidados.
En otro caso - ningún iterador es invalidado.

pop_front , pop_back Al elemento borrado.

El iterador past-the-end puede ser invalidado (definido por la implementación).

(until C++11)

El iterador past-the-end también se invalida.

(since C++11)

Notas de invalidación

Tipos de miembros

Tipo de miembro Definición
value_type T
allocator_type Allocator
size_type Tipo entero sin signo (normalmente std::size_t )
difference_type Tipo entero con signo (normalmente std::ptrdiff_t )
reference value_type &
const_reference const value_type &
pointer

Allocator::pointer

(hasta C++11)

std:: allocator_traits < Allocator > :: pointer

(desde C++11)
const_pointer

Allocator::const_pointer

(hasta C++11)

std:: allocator_traits < Allocator > :: const_pointer

(desde C++11)
iterator LegacyRandomAccessIterator y ConstexprIterator (desde C++26) a value_type
const_iterator LegacyRandomAccessIterator y ConstexprIterator (desde C++26) a const value_type
reverse_iterator std:: reverse_iterator < iterator >
const_reverse_iterator std:: reverse_iterator < const_iterator >

Funciones miembro

construye el deque
(función miembro pública)
destruye el deque
(función miembro pública)
asigna valores al contenedor
(función miembro pública)
asigna valores al contenedor
(función miembro pública)
asigna un rango de valores al contenedor
(función miembro pública)
devuelve el asignador asociado
(función miembro pública)
Acceso a elementos
accede al elemento especificado con verificación de límites
(función miembro pública)
acceder al elemento especificado
(función miembro pública)
acceder al primer elemento
(función miembro pública)
acceder al último elemento
(función miembro pública)
Iteradores
devuelve un iterador al inicio
(función miembro pública)
(C++11)
devuelve un iterador al final
(función miembro pública)
devuelve un iterador inverso al principio
(función miembro pública)
(C++11)
devuelve un iterador inverso al final
(función miembro pública)
Capacidad
verifica si el contenedor está vacío
(función miembro pública)
devuelve el número de elementos
(función miembro pública)
devuelve el número máximo posible de elementos
(función miembro pública)
reduce el uso de memoria liberando memoria no utilizada
(función miembro pública)
Modificadores
limpia el contenido
(función miembro pública)
inserta elementos
(función miembro pública)
inserta un rango de elementos
(función miembro pública)
(C++11)
construye un elemento en el lugar
(función miembro pública)
elimina elementos
(función miembro pública)
agrega un elemento al final
(función miembro pública)
construye un elemento en el lugar al final
(función miembro pública)
agrega un rango de elementos al final
(función miembro pública)
elimina el último elemento
(función miembro pública)
inserta un elemento al principio
(función miembro pública)
construye un elemento in situ al principio
(función miembro pública)
agrega un rango de elementos al principio
(función miembro pública)
elimina el primer elemento
(función miembro pública)
cambia el número de elementos almacenados
(función miembro pública)
intercambia los contenidos
(función miembro pública)

Funciones no miembro

(eliminado en C++20) (eliminado en C++20) (eliminado en C++20) (eliminado en C++20) (eliminado en C++20) (C++20)
compara lexicográficamente los valores de dos deque s
(plantilla de función)
especializa el algoritmo std::swap
(plantilla de función)
elimina todos los elementos que cumplen criterios específicos
(plantilla de función)

Guías de deducción

(desde C++17)

Notas

Macro de prueba de características Valor Estándar Característica
__cpp_lib_containers_ranges 202202L (C++23) Construcción e inserción de rangos para contenedores
__cpp_lib_constexpr_deque 202502L (C++26) constexpr std::deque

Ejemplo

#include <deque>
#include <iostream>
int main()
{
    // Crear un deque que contenga enteros
    std::deque<int> d = {7, 5, 16, 8};
    // Agregar un entero al principio y al final del deque
    d.push_front(13);
    d.push_back(25);
    // Iterar e imprimir valores del deque
    for (int n : d)
        std::cout << n << ' ';
    std::cout << '\n';
}

Salida:

13 7 5 16 8 25

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 230 C++98 T no se requería que fuera CopyConstructible
(un elemento de tipo T podría no poder ser construido)
T también se requiere que
sea CopyConstructible

Véase también

adapta un contenedor para proporcionar queue (estructura de datos FIFO)
(plantilla de clase)