Dominar std::list en C++: Sintaxis, Funciones y Ejemplos Prácticos

¿Qué es std::list?

En C++, std::list es un contenedor de secuencia que almacena los elementos como una lista doblemente enlazada. Esta estructura permite insertar o eliminar elementos en cualquier posición en tiempo constante, mientras se itera sobre la lista en ambas direcciones. Aunque no proporciona acceso aleatorio rápido como std::vector, destaca en escenarios donde ocurren inserciones o eliminaciones frecuentes.

El contenedor gestiona automáticamente la memoria mediante un allocator, por lo que puede crecer o reducirse desde ambos extremos durante la ejecución.

¿Por qué usar std::list?

• Inserción y eliminación en tiempo constante en cualquier posición de la secuencia.
• Eficiente para algoritmos que mueven elementos con frecuencia.
• Ideal cuando el tamaño del contenedor cambia de forma impredecible.

Definición de una lista

Para usar std::list, incluya la cabecera <list>:

#include <list> // Definición de plantilla // template<class T, class Alloc = std::allocator<T>> class list; 

Parámetros:

• T – Tipo de los elementos almacenados. Se permite cualquier tipo copiable.
• Alloc – Tipo de allocator. El std::allocator por defecto suele ser suficiente.

Ejemplo 1: Iteración básica

#include <iostream> #include <list> int main() { std::list<int> my_list{12, 5, 10, 9}; for (int x : my_list) { std::cout << x << '\n'; } } 

Salida:

Operaciones comunes de std::list

Constructores

• std::list() – Constructor por defecto; crea una lista vacía.
• std::list(n) – Constructor de relleno; crea n elementos construidos por defecto.
• std::list(first, last) – Constructor de rango; copia elementos de otro rango.
• std::list(const list&) – Constructor de copia.
• std::list(list&&) – Constructor de movimiento.
• std::list(std::initializer_list<T>) – Constructor de lista de inicialización.

Ejemplo 2: Variantes de constructores

#include <iostream> #include <list> int main() { std::list<int> l; // vacía std::list<int> l1{10, 20, 30}; std::list<int> l2(l1.begin(), l1.end()); // copia de rango std::list<int> l3(std::move(l1)); // movimiento std::cout << "Tamaño de l: " << l.size() << '\n'; std::cout << "Contenido de l2:\n"; for (int x : l2) std::cout << x << '\n'; std::cout << "Contenido de l3:\n"; for (int x : l3) std::cout << x << '\n'; } 

Salida:

Propiedades del contenedor

• Secuencia – Los elementos se almacenan en un orden lineal accesible por posición.
• Lista doblemente enlazada – Cada nodo conoce su predecesor y sucesor, permitiendo inserciones/eliminaciones en tiempo constante.
• Consciente del allocator – Usa un allocator para solicitar memoria según sea necesario.

Inserción de elementos

Use push_front, push_back o insert para añadir elementos.

Ejemplo 3: Inserciones mixtas

#include <algorithm> #include <iostream> #include <list> int main() { std::list<int> my_list{12, 5, 10, 9}; my_list.push_front(11); // frente my_list.push_back(18); // final auto it = std::find(my_list.begin(), my_list.end(), 10); if (it != my_list.end()) { my_list.insert(it, 21); // antes de 10 } for (int x : my_list) std::cout << x << '\n'; } 

Salida:

Eliminación de elementos

Use erase para eliminar elementos individuales o rangos.

Ejemplo 4: Demostración de erase

#include <iostream> #include <list> int main() { std::list<int> my_list{12, 5, 10, 9}; std::cout << "Antes de la eliminación:\n"; for (int x : my_list) std::cout << x << '\n'; my_list.erase(my_list.begin()); // eliminar primero std::cout << "Después de la eliminación:\n"; for (int x : my_list) std::cout << x << '\n'; } 

Salida:

Conclusiones clave

• std::list es un contenedor de secuencia doblemente enlazado.
• Ofrece inserciones/eliminaciones en tiempo constante desde cualquier posición.
• Se admite recorrido secuencial en ambas direcciones.
• El acceso aleatorio no es eficiente; use std::vector cuando necesite indexación rápida.
• Constructores, iteradores y conciencia de allocator hacen a std::list versátil para conjuntos de datos dinámicos.