std:: deque
|
Definido en el encabezado
<deque>
|
||
|
template
<
class
T,
|
(1) | |
|
namespace
pmr
{
template
<
class
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,
|
(desde C++26) |
Contenidos |
Parámetros de plantilla
| T | - |
El tipo de los elementos.
|
||||
| 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
|
Esta sección está incompleta
Razón: Todavía hay algunas inexactitudes en esta sección, consulte las páginas de funciones miembro individuales para más detalles |
| 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.
|
||||
| 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.
|
||||
| pop_front , pop_back |
Al elemento borrado.
|
Notas de invalidación
- Al insertar en cualquiera de los extremos del deque, las referencias no se invalidan por insert y emplace .
- push_front , push_back , emplace_front y emplace_back no invalidan ninguna referencia a elementos del deque.
- Al eliminar en cualquiera de los extremos del deque, las referencias a elementos no eliminados no se invalidan por erase , pop_front y pop_back .
- Una llamada a resize con un tamaño menor no invalida ninguna referencia a elementos no eliminados.
- Una llamada a resize con un tamaño mayor no invalida ninguna referencia a elementos del deque.
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
|
|
||||
const_pointer
|
|
||||
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) |
|
|
(C++23)
|
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 |
|
|
(C++11)
|
devuelve un iterador al inicio
(función miembro pública) |
|
(C++11)
|
devuelve un iterador al final
(función miembro pública) |
|
(C++11)
|
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) |
|
|
(
DR*
)
|
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) |
|
|
(C++23)
|
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) |
|
|
(C++11)
|
construye un elemento en el lugar al final
(función miembro pública) |
|
(C++23)
|
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) |
|
|
(C++11)
|
construye un elemento in situ al principio
(función miembro pública) |
|
(C++23)
|
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) |