迭代器的STL容器如何表现？

Question

This question appeared to me rather out of academic interest than an actual use-case:

The STL associative containers, namely [multi]set and [multi]map, contain overloaded methods like:

// for std::map
void erase ( iterator position );
size_type erase ( const key_type& x );

// for std::set
iterator  erase (const_iterator position);
size_type erase (const value_type& val);

My question: What if key_type , resp. value_type is iterator or const_iterator ?

I am aware that it is dangerous and probably useless to store iterators in a container. But how would an actual STL implementation behave? Is the behaviour even defined?

Answer 1

The thing is that the iterator types would be different. It can't ever happen that they are the same. The reason: The following equalities had to hold in this case:

map<K, V>::iterator == K
map<K, V>::const_iterator == K

However, these equalities can't hold (do you see the recursion)? Remember that iterator types depend on the container type, including its template parameters.

So in the following example, the key type and the iterator type are different, as much as you try to make them equal:

map<map<int,int>::iterator, int> i;

Indeed, because of the reason from above, I can't instantiate a map which key equals its iterator type. Thus, the overloaded erase methods look like this:

void erase ( map<map<int,int>::iterator, int>::iterator position );
size_type erase ( const map<int,int>::iterator & x );

So the overload will never be ambiguous. If the types were equal, it'd be ambiguous, see this: http://ideone.com/fMdwru . However, the compiler only complains as long as you are using the method. So, let's say we could introduce ambiguity here, it only bothers us as long as we want to use the method. I mean, we still could instantiate the map type (if it existed).

Answer 2

There's nothing inherently wrong with storing iterators in a container. Two main issues to be aware of are:

1. you may need to know which container each iterator refers to;
2. you have to know which operations on the original container would invalidate which iterators.

My question: What if key_type , resp. value_type is iterator or const_iterator ?

If all four types refer to the same container type, the answer is that they can't be the same, by definition.

Answer 3

There's nothing wrong with doing this, and it's not useless either. :)

Remeber that iterators are basically just generalized pointers. When in doubt, assume that they behave like pointers. You can create containers of pointers, so you can also create containers of iterators.

Of course, you have to keep in mind that if you modify a container, iterators pointing to that container may be invalidated (depending on the operation performed and the type of container), but that just means you have to know that the stored iterators stay valid.