Does pop_back() really invalidate *all* iterators on an std::vector?

Question

std::vector ints;

// ... fill ints with random values

for(std::vector::iterator it = ints.begin(); it != ints.end(); )
{
    if(*it < 10)
         


        

Answer 1

Check out the information here (cplusplus.com):

Delete last element

Removes the last element in the vector, effectively reducing the vector size by one and invalidating all iterators and references to it.

Answer 2

pop_back() will only invalidate it if it was pointing to the last item in the vector. Your code will therefore fail whenever the last int in the vector is less than 10, as follows:

*it = ints.back(); // Set *it to the value it already has
ints.pop_back(); // Invalidate the iterator
continue; // Loop round and access the invalid iterator

Answer 3

(I use the numbering scheme as used in the C++0x working draft, obtainable here

Table 94 at page 732 says that pop_back (if it exists in a sequence container) has the following effect:

{ iterator tmp = a.end(); 
--tmp; 
a.erase(tmp); } 

23.1.1, point 12 states that:

Unless otherwise specified (either explicitly or by defining a function in terms of other functions), invoking a container member function or passing a container as an argument to a library function shall not invalidate iterators to, or change the values of, objects within that container.

Both accessing end() as applying prefix-- have no such effect, erase() however:

23.2.6.4 (concerning vector.erase() point 4):

Effects: Invalidates iterators and references at or after the point of the erase.

So in conclusion: pop_back() will only invalidate an iterator to the last element, per the standard.

Answer 4

pop_back() invalidates only iterators that point to the last element. From C++ Standard Library Reference:

Inserting or removing elements invalidates references, pointers, and iterators that refer to the following element. If an insertion causes reallocation, it invalidates all references, iterators, and pointers.

So to answer your question, no it does not invalidate all iterators.

However, in your code example, it can invalidate it when it is pointing to the last element and the value is below 10. In which case Visual Studio debug STL will mark iterator as invalidated, and further check for it not being equal to end() will show an assert.

If iterators are implemented as pure pointers (as they would in probably all non-debug STL vector cases), your code should just work. If iterators are more than pointers, then your code does not handle this case of removing the last element correctly.

Answer 5

The call to pop_back() removes the last element in the vector and so the iterator to that element is invalidated. The pop_back() call does not invalidate iterators to items before the last element, only reallocation will do that. From Josuttis' "C++ Standard Library Reference":

Inserting or removing elements invalidates references, pointers, and iterators that refer to the following element. If an insertion causes reallocation, it invalidates all references, iterators, and pointers.