Biblioteca estándar de C++<deque>

En C++,<deque>es parte de la Biblioteca de Plantillas Estándar (STL) y proporciona la implementación de una cola doblemente terminada (double-ended queue).

Una cola doblemente terminada es una estructura de datos lineal que permite operaciones de inserción y eliminación en ambos extremos.

<deque>su nombre completo es "double-ended queue", existe en C++ como una clase de plantilla y permite almacenar datos de cualquier tipo.

<deque>es un arreglo dinámico que proporciona capacidad de acceso aleatorio rápido y permite operaciones eficientes de inserción y eliminación en ambos extremos. Esto hace que<deque>sea una opción ideal para escenarios que requieren inserción y eliminación frecuente de elementos.

Sintaxis

En C++, para usar<deque>es necesario incluir el archivo de cabecera#include <deque>. A continuación se muestra<deque>la sintaxis básica de:

#include <iostream>
#include <deque>

int main() {
    std::deque<int> myDeque; // 创建一个整数类型的双端队列
    // 接下来可以进行插入、删除等操作
    return 0;
}

Operaciones comunes

A continuación se muestran algunas funciones miembro comunes del contenedor std::deque:

Nombre de la funciónDescripción de la función
deque()Constructor por defecto, crea undequecontenedor vacío.
deque(size_type n)Crea un contenedor que contienenelementos con valor predeterminadodequecontenedor.
deque(size_type n, const T& value)Crea un contenedor que contienencuyo valor esvaluededequecontenedor.
deque(initializer_list<T> il)Usando una lista de inicializaciónilconstruir undequecontenedor.
operator=Operador de asignación, asigna adequeun contenedor.
assign()Reemplaza con nuevos valoresdequetodos los elementos del contenedor.
at(size_type pos)Devuelveposel elemento en la posición, y realiza verificación de límites.
operator[](size_type pos)Devuelveposel elemento en la posición, sin verificación de límites.
front()Devuelve una referencia al primer elemento.
back()Devuelve una referencia al último elemento.
begin()Devuelve un iterador que apunta al primer elemento.
end()Devuelve un iterador que apunta a la posición posterior al último elemento.
rbegin()Devuelve un iterador inverso que apunta al último elemento.
rend()Devuelve un iterador inverso que apunta a la posición anterior al primer elemento.
empty()Comprueba si el contenedor está vacío.
size()Devuelve el número de elementos del contenedor.
max_size()Devuelve el número máximo de elementos que puede contener el contenedor.
clear()Elimina todos los elementos del contenedor.
insert(iterator pos, const T& value)EnposInsertar en la posiciónvalueel elemento.
erase(iterator pos)Eliminaposel elemento en la posición.
push_back(const T& value)Añade al final del contenedorvalueel elemento.
pop_back()Elimina el elemento al final del contenedor.
push_front(const T& value)Añade al inicio del contenedorvalueel elemento.
pop_front()Elimina el elemento al inicio del contenedor.
resize(size_type count)Ajusta el tamaño del contenedor acount, y las partes sobrantes se rellenan con valores predeterminados.
swap(deque& other)Intercambia el contenido de dosdequecontenedores.
get_allocator()Devuelve una copia del objeto asignador utilizado para construir la cola doblemente terminada.

Ejemplo

A continuación se muestra un ejemplo que usa<deque>incluyendo operaciones de inserción, acceso y eliminación de elementos.

Ejemplo

#include <iostream>
#include <deque>

int main() {
    std::deque<int> myDeque;

    // Insertar elementos
    myDeque.push_back(10);
    myDeque.push_back(20);
    myDeque.push_front(5);

    // Acceder a elementos
    std::cout << "Deque contains: ";
    for (int i = 0; i < myDeque.size(); ++i) {
        std::cout << myDeque[i] << " ";
    }
    std::cout << std::endl;

    // Eliminar elementos
    myDeque.pop_back();
    myDeque.pop_front();

    // Volver a acceder a elementos
    std::cout << "Deque after popping: ";
    for (int i = 0; i < myDeque.size(); ++i) {
        std::cout << myDeque[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

Resultado de salida:

Deque contains: 5 10 20 
Deque after popping: 10

Cuando no se conoce la longitud de deque, se pueden usar deque.front() y deque.back() para acceder a los elementos del frente y del final:

Ejemplo

#include <iostream>
#include <deque>

int main() {
    std::deque<int> d;

    // Añadir elementos a la cola doblemente terminada
    d.push_back(10);
    d.push_back(20);
    d.push_front(5);

    // Acceder al elemento frontal
    std::cout << "Front element: " << d.front() << std::endl;

    // Acceder al elemento posterior
    std::cout << "Back element: " << d.back() << std::endl;

    // Modificar el elemento frontal
    d.front() = 15;

    // Modificar el elemento posterior
    d.back() = 25;

    // Volver a acceder a los elementos
    std::cout << "Modified front element: " << d.front() << std::endl;
    std::cout << "Modified back element: " << d.back() << std::endl;

    return 0;
}

El resultado de salida es:

Front element: 5
Back element: 20
Modified front element: 15
Modified back element: 25

Nota:Antes de usar front() o back(), asegúrate de que la cola doblemente terminada no esté vacía; de lo contrario, se provocará un comportamiento indefinido. Si necesitas comprobar si la cola doblemente terminada está vacía, puedes usar la función miembro empty().

Otras extensiones