C++ const std::map reference fails to compile

Question

Is there a reason why passing a reference to a std::map as const causes the [] operator to break? I get this compiler error (gcc 4.2) when I use const:

error: no match for ‘operator[]’ in ‘map[name]’

Here's the function prototype:

void func(const char ch, std::string &str, const std::map<std::string, std::string> &map);

And, I should mention that there is no problem when I remove the const keyword in front of std::map.

If I've been instructed correctly, the [] operator will actually insert a new pair into the map if it doesn't find the key, which would of course explain why this happens, but I can't imagine that this would ever be acceptable behavior.

If there is a better method, like using find instead of [], I'd appreciate it. I can't seem to get find to work either though... I receive const mismatched iterator errors.

Answer 1

Yes you can't use operator[]. Use find, but note it returns const_iterator instead of iterator:

std::map<std::string, std::string>::const_iterator it;
it = map.find(name);
if(it != map.end()) {
    std::string const& data = it->second;
    // ...
}

It's like with pointers. You can't assign int const* to int*. Likewise, you can't assign const_iterator to iterator.

Answer 2

When you're using operator[], std::map looks for item with given key. If it does not find any, it creates it. Hence the problem with const.

Use find method and you'll be fine.

Can you please post code on how you're trying to use find() ? The right way would be :

if( map.find(name) != map.end() )
{
   //...
}

Answer 3

If you're using C++11, std::map::at should work for you.

The reason std::map::operator[] doesn't work is that in the event of the key you're looking for not existing in the map, it will insert a new element using the provided key and return a reference to it (See the link for details). This is not possible on a const std::map.

The 'at' method, however, will throw an exception if the key doesn't exist. That being said, it is probably a good idea to check for the existence of the key using the std::map::find method before attempting to access the element using the 'at' method.

Answer 4

Probably because there is no const operator[] in std::map. operator[] will add the element you're looking for if it doesn't find it. Therefore, use the find() method if you want to search without the possibility of adding.

Answer 5

For your "const mismatched iterator errors" :

find() has two overloads:

      iterator find ( const key_type& x );
const_iterator find ( const key_type& x ) const;

My guess is that you're getting this error because you're doing something like assigning a non-const iterator (on the left) to the result of a find() call on a const map:

iterator<...> myIter /* non-const */ = myConstMap.find(...)

That would result in an error, though perhaps not the one you're seeing.