Los contenedores secuenciales forman la columna vertebral de la biblioteca estándar de C++ para manejar colecciones ordenadas de datos. A diferencia de los contenedores asociativos (como map o set), estos organizan elementos según el orden de inserción y priorizan operaciones basadas en posición relativa —no en claves—, lo que los hace ideales para escenarios donde la secuencialidad y la eficiencia en modificaciones locales son críticas.

Tipos Principales y Sus Perfiles de Rendimiento

Cada contenedor ofrece un equilibrio distinto entre acceso aleatorio, inserción/eliminación en distintas zonas y uso de memoria:

Operaciones Comunes y Diferencias Semánticas

Aunque comparten interfaces similares, su comportamiento varía significativamente:

• Inserción: push_back() está disponible en vector, deque y list; push_front() se soporta en deque, list y forward_list. vector no ofrece push_front() debido a su costo lineal.
• Acceso: Solo vector y deque permiten operator[] y at(). En list, acceder al quinto elemento requiere recorrer desde el inicio —no es constante.
• Búsqueda de posición: insert(iter, val) inserta antes del iterador. Para forward_list, se usa insert_after(pos, val), ya que no existe un "iterador anterior" válido.

Ejemplos Reescritos con Enfoque Moderno

Uso de emplace_back para construir objetos in situ, evitando copias innecesarias:

// Versión tradicional (construcción + copia)
std::vector<std::pair<int, std::string>> records;
records.push_back(std::make_pair(42, "respuesta"));

// Versión optimizada (construcción directa)
records.emplace_back(42, "respuesta"); // No se crea ni copia ningún objeto intermedio

Gestión eficiente de capacidad en vector:

std::vector<double> measurements;
measurements.reserve(5000); // Preasigna espacio para 5000 elementos
for (int i = 0; i < 5000; ++i) {
    measurements.emplace_back(compute_value(i));
}
// Evita hasta 12 reasignaciones internas típicas sin reserve()

Manejo seguro de forward_list mediante iteradores especiales:

std::forward_list<char> chars{'a', 'b', 'c'};
auto sentinel = chars.before_begin(); // Iterador que apunta *antes* del primer nodo
chars.insert_after(sentinel, 'x'); // Inserta 'x' al inicio: {'x','a','b','c'}
auto it = chars.begin();
std::advance(it, 2); // it ahora apunta a 'b'
chars.insert_after(it, 'y'); // {'x','a','b','y','c'}

Invalidación de Iteradores: Reglas Esenciales

La estabilidad de los iteradores depende del tipo de contenedor y la operación realizada:

• vector: Cualquier inserción que provoque realocación invalida todos los iteradores, referencias y punteros. Inserciones en el medio invalidan los que apuntan desde esa posición en adelante.
• deque: Inserciones en los extremos no invlaidan iteradores; inserciones en el medio sí pueden hacerlo.
• list y forward_list: Las inserciones nunca invalidan iteradores existentes (excepto los que apuntan al elemento insertado). Las eliminaciones solo invalidan el iterador del nodo borrado.

Adaptadores de Contenedores

Aunque no son contenedores secuenciales propiamente dichos, los adaptadores encapsulan funcionalidad específica sobre una base subyacente:

• std::stack<T, Container=std::deque<T>>: LIFO; permite push(), pop(), top().
• std::queue<T, Container=std::deque<T>>: FIFO; soporta push(), pop(), front(), back().
• std::priority_queue<T, Container=std::vector<T>, Compare=std::less<T>>: Cola con prioridad basada en heap; el elemento máximo (por defecto) siempre está en la cima.

Guía Práctica de Selección

Una matriz orientada a casos de uso:

Prácticas Recomendadas

• Prefiera vector como punto de partida; cambie solo si los perfiles de rendimiento lo exigen.
• Use reserve() cuando se conozca aproximadamente el tamaño final para evitar reasignaciones costosas.
• Reemplace push_back(x) con emplace_back(args...) cuando x sea construible directamente desde argumentos.
• Evite guardar iteradores de vector durante ciclos que modifiquen su tamaño.
• Utilice bucles basados en rango (for (const auto& x : container)) para simplificar lectura y evitar errores de índice.