std::map, pointer to map key value, is this possible?

Question

std::map<std::string, std::string> myMap;

std::map<std::string, std::string>::iterator i = m_myMap.find(some_key_string);
if(i == m_imagesMap.end())
    return NULL;

string *p = &i->first;

Is the last line valid? I want to store this pointer p somewhere else, will it be valid for the whole program life? But what will happen if I add some more elements to this map (with other unique keys) or remove some other keys, won’t it reallocate this string (key-value pair), so the p will become invalid?

Answer 1

It's not guaranteed to be safe. I think it strongly depends on implementation.

EDIT: Anyway "p" MUST be const or you could use pointer to change the key value which is bad! Actually without "const" that code should not compile on a modern compiler.

Answer 2

First, maps are guaranteed to be stable, i.e. the iterators are not invalidated by element insertion or deletion (beside the element being deleted of course).

However, stability of iterator does not guarantee stability of pointers. It so happens that most implementation use pointers at least at some level to implement iterators, so it is quite safe to assume your solution will work. But what you should really store it the iterator.

What you could do is create a small object like:

struct StringPtrInMap
{
  typedef std::map<string,string>::iterator iterator;
  StringPtrInMap(iterator i) : it(i) {}
  string& operator*() { return it->first; }
  const string& oeprator*() const { return it->first; }
  string* operator->() { return &it->first; }
  const string* operator->() const { return &it->first; }
  iterator it;
}

And then store that instead of a string pointer.

Answer 3

Section 23.1.2#8 (associative container requirements):

The insert members shall not affect the validity of iterators and references to the container, and the erase members shall invalidate only iterators and references to the erased elements.

So yes storing pointers to data members of a map element is guaranteed to be valid, unless you remove that element.

Answer 4

If you're not sure which operations will invalidate your iterators, you can look it up pretty easily in the reference. For instance for vector::insert it says:

This effectively increases the vector size, which causes an automatic reallocation of the allocated storage space if, and only if, the new vector size surpases the current vector capacity. Reallocations in vector containers invalidate all previously obtained iterators, references and pointers.

map::insert on the other hand doesn't mention anything of the sort.

As Pierre said, you should store the iterator rather than the pointer, though.

Answer 5

Why are you wanting to do this?

You can't change the value of *p, since it's const std::string. If you did change it, then you might break the invariants of the container by changing the sort order of the elements.

Unless you have other requirements that you haven't given here, then you should just take a copy of the string.