C++ Iterador / Invalidación de puntero


Ejemplo

Los iteradores y los punteros que apuntan a un std::vector pueden volverse inválidos, pero solo cuando se realizan ciertas operaciones. El uso de iteradores / punteros no válidos resultará en un comportamiento indefinido.

Las operaciones que invalidan los iteradores / punteros incluyen:

  • Cualquier operación de inserción que cambie la capacity del vector invalidará todos los iteradores / punteros:

    vector<int> v(5); // Vector has a size of 5; capacity is unknown.
    int *p1 = &v[0];
    v.push_back(2);   // p1 may have been invalidated, since the capacity was unknown.
    
    v.reserve(20);    // Capacity is now at least 20.
    int *p2 = &v[0];
    v.push_back(4);   // p2 is *not* invalidated, since the size of `v` is now 7.
    v.insert(v.end(), 30, 9); // Inserts 30 elements at the end. The size exceeds the
                              // requested capacity of 20, so `p2` is (probably) invalidated.
    int *p3 = &v[0];
    v.reserve(v.capacity() + 20); // Capacity exceeded, thus `p3` is invalid.
    
C ++ 11
auto old_cap = v.capacity();
v.shrink_to_fit();
if(old_cap != v.capacity())
    // Iterators were invalidated.
  • Cualquier operación de inserción, que no aumente la capacidad, todavía invalidará los iteradores / punteros que apuntan a los elementos en la posición de inserción y los pasan. Esto incluye el iterador end :

    vector<int> v(5);
    v.reserve(20);                 // Capacity is at least 20.
    int *p1 = &v[0];
    int *p2 = &v[3];
    v.insert(v.begin() + 2, 5, 0); // `p2` is invalidated, but since the capacity
                                   // did not change, `p1` remains valid.
    int *p3 = &v[v.size() - 1];
    v.push_back(10); // The capacity did not change, so `p3` and `p1` remain valid.
    
  • Cualquier operación de eliminación invalidará los iteradores / punteros que apuntan a los elementos eliminados y a cualquier elemento más allá de los elementos eliminados. Esto incluye el iterador end :

    vector<int> v(10);
    int *p1 = &v[0];
    int *p2 = &v[5];
    v.erase(v.begin() + 3, v.end()); // `p2` is invalid, but `p1` remains valid.
    
  • operator= (copiar, mover u otro) y clear() invalidarán todos los iteradores / punteros que apuntan al vector.