Gestión de iteradores e invalidación en std::vector

Cuando trabajas con std::vector, estás operando sobre un contenedor que garantiza la contigüidad de sus elementos en memoria. Esta propiedad es la que permite que el acceso sea extremadamente rápido, pero también es la razón por la cual su estructura es tan sensible a las modificaciones. La invalidez de iteradores ocurre cuando una operación de modificación altera la ubicación de los elementos o la propia base de la memoria del contenedor.

Si realizas un push_back() o un insert() y el vector necesita aumentar su capacity() para alojar nuevos elementos, el contenedor reserva un nuevo bloque de memoria, mueve todos los objetos existentes al nuevo bloque y libera la memoria antigua. En ese momento, cualquier iterador, puntero o referencia que tuviera tus objetos se convierte en un dangling pointer (apunta a memoria que ya no es válida), provocando un comportamiento indefinido (undefined behavior). Incluso si no hay reasignación de memoria, un erase() o un insert() desplazan los elementos hacia la derecha o la izquierda, invalidando todos los iteradores desde el punto de la modificación hasta el final del contenedor.

Para usarlo de forma segura, debes usar siempre el valor de retorno de erase() e insert(), que devuelve el iterador al siguiente elemento válido, o bien llamar a reserve() previamente si conoces el tamaño máximo que alcanzará el vector, evitando así reasignaciones inesperadas. Por último, debes evitar std::vector<bool>. Aunque parece un contenedor de bool, es una especialización de [C++98] diseñada para ahorrar espacio empaquetando los valores en bits. Esto significa que sus elementos no son direccionables (no puedes obtener la dirección de un bit), lo que rompe la semántica de los contenedores estándar y hace que data() no esté disponible.

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdint>

struct SensorData {
    int id;
    float value;

    // Necesario para std::remove_if o comparaciones
    bool operator==(const SensorData& other) const = default;
};

int main() {
    // 1. Borrado seguro durante la iteración
    // Si borramos elementos, el iterador actual queda invalidado.
    // Debemos asignar el resultado de erase() al iterador.
    std::vector<int> buffer = {10, 15, 20, 25, 30, 35};
    
    std::cout << "Borrando impares de forma segura...\n";
    for (auto it = buffer.begin(); it != buffer.end(); /* no incrementamos aquí */) {
        if (*it % 2 != 0) {
            it = buffer.erase(it); // it ahora apunta al siguiente elemento válido
        } else {
            ++it; // Solo incrementamos si no hemos borrado nada
        }
    }

    // 2. Prevención de reasignación mediante reserve()
    // Al reservar espacio, garantizamos que los iteradores sigan siendo válidos
    // siempre que no excedamos la capacidad reservada.
    std::vector<SensorData> sensors;
    sensors.reserve(10); // Reservamos espacio para 10 elementos
    
    sensors.push_back({1, 25.5f});
    auto it_sensor = sensors.begin();
    
    // Como la capacidad es 10, esta inserción NO provocará una reasignación.
    // El iterador 'it_sensor' sigue siendo válido.
    sensors.insert(sensors.begin(), {0, 0.0f});
    
    std::cout << "Sensor con ID estable: " << it_sensor->id << "\n";

    // 3. El problema de std::vector<bool> y la solución estándar
    // std::vector<bool> NO es un contenedor de objetos reales, es un proxy de bits.
    std::vector<bool> bits_problematic = {true, false, true};
    // auto ref = bits_problematic[0]; // ERROR: No puedes obtener una bool& de un bit
    
    // Para comportamientos estándar (donde los elementos sean direccionables),
    // usa std::vector<uint8_t> o std::deque<bool>.
    std::vector<uint8_t> flags = {1, 0, 1};
    uint8_t& flag_ref = flags[0]; // Esto sí es legal y seguro
    flag_ref = 1;
    std::cout << "Flag segura: " << static_cast<int>(flags[0]) << "\n";

    return 0;
}

Análisis del código

En la primera parte, observamos el patrón correcto para eliminar elementos mientras iteramos. Si hiciéramos buffer.erase(it); ++it;, tras borrar un elemento, el iterador it quedaría invalidado y el ++it posterior intentaría acceder a una dirección de memoria ya liberada o desplazada, provocando un crash. La asignación it = buffer.erase(it) es fundamental porque el método erase devuelve un iterador válido que apunta al elemento inmediatamente posterior al que acaba de ser eliminado.

En el segundo bloque, demonstramos la importancia de reserve(). Al llamar a sensors.reserve(10), el std::vector reserva memoria suficiente para 10 SensorData de golpe. Cuando ejecutamos sensors.insert(...), el vector comprueba su capacity() y, al ver que aún tiene espacio, simplemente desplaza los elementos existentes sin necesidad de buscar un nuevo bloque de memoria. Esto mantiene la validez de it_sensor. Si no hubiéramos usado reserve y el vector hubiera alcanzado su límite, it_sensor habría quedado apuntando a memoria antigua (dangling).

Finalmente, el ejemplo de flags muestra la alternativa correcta a std::vector<bool>. En flags, al ser un std::vector<uint8_t>, cada elemento es un byte con una dirección de memoria propia y única. Esto permite que flags[0] devuelva una verdadera uint8_t&, permitiendo la manipulación directa y segura de la memoria, a diferencia de la especialización de bits de std::vector<bool> que utiliza objetos proxy para simular el acceso a los bits.

El error frecuente
Un error clásico es intentar borrar elementos en un bucle for de la siguiente manera:

for (auto it = v.begin(); it != v.end(); ++it) {
    if (condicion( *it )) {
        v.erase(it); // ERROR: 'it' queda invalidado aquí
    }
}

Este código causa un error crítico porque v.erase(it) invalida el iterador it. La siguiente iteración del bucle intentará realizar ++it sobre un iterador que ya no es válido, o saltará el elemento que acababa de ocupar la posición borrada. Herramientas como AddressSanitizer (con el flag -fsanitize=address) detectarán este uso de memoria inválida inmediatamente durante la ejecución.

N° 84