Are iterators still valid when the underlying elements have been moved?-CodePudding

If I have an iterator pointing to an element in an STL container, and I moved the element with the iterator, does the standard guarantee that the iterator is still valid? Can I use it with container's method, e.g. container::erase?

Also does it matter, if the container is a continuous one, e.g. vector, or non-continuous one, e.g. list?

std::list<std::string> l{"a", "b", "c"};
auto iter = l.begin();
auto s = std::move(*iter);
l.erase(iter);       // <----- is it valid to erase it, whose underlying element has been removed?

CodePudding user response：

Yes, you've modified the object in the container. You've not modified the container itself so the iterator is still valid

CodePudding user response：

"Moving" an underlying element may not be the best name to use in this context. The name of this operation express the intention behind it but not how it really works.

In fact, the move operation is a form of copy operation with one difference: it is allowed to change the state of the "copied" object if it speeds up the execution. In case of the std::string this means that the internal buffer containing characters may be not deep-copied but just copied by address. The original object has to be then set to an empty state, to tell it to not use this buffer anymore. (Emptying the source string is not guaranteed. Optimizations of std::string are more complicated than I described.)

The important thing is that after the move operation, the original object is still there. It's just not guaranteed to have any specific state.

CodePudding user response：

In this particular case you've done nothing to the iterator, but much rather to the object within it, so yes: The iterator remains valid.

But if you look at std::list::erase, it sports a line such as "References and iterators to the erased elements are invalidated. Other references and iterators are not affected."

So if you tried to do *iter after erase, it would cause your program to fail.

This may seem obvious for erase, but there are other operations where it is not as obvious.

For std::list for example, the reference page says:

Adding, removing and moving the elements within the list or across several lists does not invalidate the iterators or references. An iterator is invalidated only when the corresponding element is deleted.

For std::vector on the other hand, the reference for the push_back method says:

If the new size() is greater than capacity() then all iterators and references (including the past-the-end iterator) are invalidated. Otherwise only the past-the-end iterator is invalidated.

That means, unlike with std::list, it is not generally safe to keep an iterator to an element around, if the vector grows (because the underlying storage location of the item changes).