Does moving a vector invalidate iterators?

by

While it might be reasonable to assume that iterators are still valid after a move, I don’t think the Standard actually guarantees this. Therefore, the iterators are in an undefined state after the move.

There is no reference I can find in the Standard which specifically states that iterators that existed before a move are still valid after the move.

On the surface, it would seem to be perfectly reasonable to assume that an iterator is typically implemented as pointers in to the controlled sequence. If that’s the case, then the iterators would still be valid after the move.

But the implementation of an iterator is implementation-defined. Meaning, so long as the iterator on a particular platform meets the requirements set forth by the Standard, it can be implemented in any way whatsoever. It could, in theory, be implemented as a combination of a pointer back to the vector class along with an index. If that’s the case, then the iterators would become invalid after the move.

Whether or not an iterator is actually implemented this way is irrelevant. It could be implemented this way, so without a specific guarantee from the Standard that post-move iterators are still valid, you cannot assume that they are. Bear in mind also that there is such a guarantee for iterators after a swap. This was specifically clarified from the previous Standard. Perhaps it was simply an oversight of the Std comittee to not make a similar clarification for iterators after a move, but in any case there is no such guarantee.

Therefore, the long and the short of it is you can’t assume your iterators are still good after a move.

EDIT:

23.2.1/11 in Draft n3242 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.

This might lead one to conclude that the iterators are valid after a move, but I disagree. In your example code, a_iter was an iterator in to the vector a. After the move, that container, a has certainly been changed. My conclusion is the above clause does not apply in this case.

More Related Contents:

  1. What’s the best way to iterate over two or more containers simultaneously
  2. Flattening iterator
  3. Why use non-member begin and end functions in C++11?
  4. Need iterator when using ranged-based for loops
  5. What is the reason behind cbegin/cend?
  6. Need iterator when using range-based for loops
  7. C++ Need help for a homework program that reads in a list of doubles from a file and add a string to each double
  8. How to enforce move semantics when a vector grows?
  9. Is signed integer overflow still undefined behavior in C++?
  10. using extern template (C++11)
  11. Move capture in lambda
  12. Error “undefined reference to ‘std::cout'”
  13. Constexpr Math Functions
  14. Is it possible to “store” a template parameter pack without expanding it?
  15. Which std::async implementations use thread pools?
  16. C++ how to generate all the permutations of function overloads?
  17. Why is the new random library better than std::rand()?
  18. Different ways of initializing an object in c++
  19. What is the purpose of the “final” keyword in C++11 for functions?
  20. Creating my own Iterators
  21. How to make a variadic is_same?
  22. How do shared pointers work?
  23. shared_ptr and weak_ptr differences
  24. How to determine programmatically if an expression is rvalue or lvalue in C++?
  25. Calling delete on NULL pointers – C++03 vs C++11
  26. GCC std::thread not found in namespace std
  27. Is there a way to write make_unique() in VS2012?
  28. using extern template (C++11) to avoid instantiation
  29. narrowing conversion from unsigned to double
  30. Why does this simple std::thread example not work?

Leave a Comment