std::deque

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de contenedores

De secuencias

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

deque

forward_list (C++11)

list

Asociativos

set

multiset

map

multimap

Asociativos no ordenados

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adaptadores

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Vistas

span (C++20)

mdspan (C++23)

Tablas

Invalidación de iteradores

Tabla de funciones miembro

Tabla de funciones no miembro

 

std::deque

Tipos miembro
Funciones miembro
deque::deque deque::~deque deque::operator=	deque::assign deque::assign_range (C++23) deque::get_allocator
Acceso a elementos
deque::at deque::operator[]	deque::front deque::back
Iteradores
deque::begindeque::cbegin (C++11) deque::enddeque::cend (C++11)	deque::rbegindeque::crbegin (C++11) deque::renddeque::crend (C++11)
Capacidad
deque::empty deque::size	deque::max_size deque::shrink_to_fit (DR*)
Modificadores
deque::clear deque::insert deque::insert_range (C++23) deque::emplace deque::erase deque::push_front deque::emplace_front (C++11)   deque::prepend_range (C++23)	deque::pop_front deque::push_back deque::emplace_back (C++11) deque::append_range (C++23) deque::pop_back deque::resize deque::swap
Funciones no miembro
operator==operator!=operator<operator>operator<=operator>=operator<=> (hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(C++20)	swap(std::deque) erase(std::deque)erase_if(std::deque) (C++20)(C++20)
Guías de deducción(C++17)

 

<tbody> </tbody>

Definido en el archivo de 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)

See More

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

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

El almacenamiento de un deque se expande y contrae automáticamente según sea necesario. La expansión de una deque es más barata que la expansión de un std::vector porque no implica copiar los elementos existentes a una nueva ubicación de memoria. Por otro lado, las colas doblemente terminadas suelen tener un gran coste de memoria mínimo; una cola doblemente terminada que contiene solo un elemento tiene que asignar su array interno complet (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 sobre colas doblemente terminadas es la siguiente:

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

std::deque cumple con los requerimientos de Contenedor, ContenedorConscienteDeAsignador, ContenedorDeSecuencia y ContenedorReversible.

Parámetros de plantilla

T	-	El tipo de los elementos. T debe cumplir con los requisitos de AsignablePorCopia y ConstruiblePorCopia. (hasta C++11) Los requisitos que se imponen a los elementos dependen de las operaciones actuales realizadas en el contenedor. Generalmente, se requiere que el tipo de elemento sea un tipo completo y cumpla con los requisitos de Borrable, pero muchas funciones miembro imponen requisitos más estrictos. (desde C++11)
Allocator	-	Un asignador que se usa para adquirir y liberar memoria, y para construir y destruir los elementos en esa memoria. El tipo debe cumplir con los requisitos de Asignador. El comportamiento no está definido si Allocator::value_type no es el mismo que T.

Invalidación de iteradores

Todavía hay algunas inexactitudes en esta sección, consulta las páginas de funciones miembro individuales para obtener más detalles.

Operaciones	Invalidado
Todas las operaciones de solo lectura	Nunca
swap, std::swap	El iterador después del final puede invalidarse (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 principio - solo los elementos borrados Si se borra al final - solo los elementos borrados y el iterador después del final De lo contrario - todos los iteradores se invalidan (incluyendo el iterador después del final).
resize	Si el nuevo tamaño es más pequeño que el anterior: solo los elementos borrados y el iterador después del final Si el nuevo tamaño es más grande que el anterior: todos los iteradores se invalidan De lo contrario - ninguno de los iteradores se invalida.
pop_front	Solo para el elemento borrado
pop_back	Solo para el elemento borrado y el iterador después del final.

Notas de invalidación

• Al insertar en cualquier extremidad de la cola doblemente terminada, las referencias no se invalidan por insert y emplace.
• push_front, push_back, emplace_front y emplace_back no invalidan ninguna referencia a los elementos de la cola doblemente terminada.
• Al borrar en cualquier extremidad de la cola doblemente terminada, las referencias a los elementos no borrados no se invalidan por erase, pop_front y pop_back.
• Una llamada a resize con un tamaño más pequeño no invalida ninguna referencia a los elementos no borrados.
• Una llamada a resize con un tamaño más grande no invalida ninguna referencia a los elementos de la cola doblemente terminada.

Tipos miembro

Tipo miembro	Definición
value_type	T
allocator_type	Allocator
size_type	Tipo entero sin signo (por lo general std::size_t)
difference_type	Tipo entero con signo (por lo general std::ptrdiff_t)
reference	Allocator::reference (hasta C++11) value_type& (desde C++11)
const_reference	Allocator::const_reference (hasta C++11) const value_type& (desde C++11)
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	IteradorDeAccesoAleatorioLegado
const_iterator	IteradorDeAccesoAleatorioLegado constante
reverse_iterator	std::reverse_iterator<iterator>
const_reverse_iterator	std::reverse_iterator<const_iterator>

Funciones miembro

(constructor)	Construye el contenedor deque. (función miembro pública)
(destructor)	Destruye el contenedor deque. (función miembro pública)
operator=	Asigna valores al contenedor. (función miembro pública)
assign	Asigna valores al contenedor. (función miembro pública)
assign_range (C++23)	Asigna un rango de valores al contenedor. (función miembro pública)
get_allocator	Devuelve el asignador de memoria asociado. (función miembro pública)
Acceso a elementos
at	Accede al elemento especificado con comprobación de límites. (función miembro pública)
operator[]	Accede el elemento especificado. (función miembro pública)
front	Accede al primer elemento. (función miembro pública)
back	Accede al último elemento. (función miembro pública)
Iteradores
begin cbegin (C++11)	Devuelve un iterador al principio. (función miembro pública)
end cend (C++11)	Devuelve un iterador al final. (función miembro pública)
rbegincrbegin (C++11)	Devuelve un iterador inverso al principio. (función miembro pública)
rend crend (C++11)	Devuelve un iterador inverso al final. (función miembro pública)
Capacidad
empty	Comprueba si el contenedor está vacío. (función miembro pública)
size	Devuelve el número de elementos. (función miembro pública)
max_size	Devuelve el número máximo posible de elementos. (función miembro pública)
shrink_to_fit (C++11)	Reduce el uso de memoria liberando memoria no utilizada. (función miembro pública)
Modificadores
clear	Borra el contenido. (función miembro pública)
insert	Inserta elementos (función miembro pública)
insert_range (C++23)	Inserta un rango de elementos. (función miembro pública)
emplace (C++11)	Construye el elemento en el sitio. (función miembro pública)
erase	Borra elementos (función miembro pública)
push_back	Agrega elementos al final. (función miembro pública)
emplace_back (C++11)	Construye un elemento en el sitio al final. (función miembro pública)
append_range (C++23)	Agrega un rango de elementos al final. (función miembro pública)
pop_back	Remueve el último elemento. (función miembro pública)
push_front	Inserta un elemento al principio del contenedor. (función miembro pública)
emplace_front (C++11)	Construye un elemento en el sitio al principio del contenedor. (función miembro pública)
prepend_range (C++23)	Agrega un rango de elementos al principio. (función miembro pública)
pop_front	Remueve el primer elemento. (función miembro pública)
resize	Cambia el número de elementos almacenados. (función miembro pública)
swap	Intercambia el contenido. (función miembro pública)

Funciones no miembro

operator==operator!=operator<operator<=operator>operator>=operator<=> (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 deque. (plantilla de función)
std::swap(std::deque)	Especializa el algoritmo std::swap. (plantilla de función)
erase(std::deque)erase_if(std::deque) (C++20)	Borra todos los elementos que satisfacen un criterio específico. (plantilla de función)

Guías de deducción(desde C++17)

Ejemplo

Ejecuta este código

#include <iostream>
#include <deque>

int main()
{
    // Crear cola doblemente terminada que contiene enteros
    std::deque<int> d = {7, 5, 16, 8};

    // Agregar un entero al principio y al final de la cola
    d.push_front(13);
    d.push_back(25);

    // Iterar e imprimir los valores en la cola
    for(int n : d) {
        std::cout << n << '\n';
    }
}

Salida:

13
7
5
16
8
25

Véase también

queue

Adapta un contenedor para proporcionar una cola (estructura de datos PEPS o FIFO, del inglés first in, first out). (plantilla de clase)