Unordered Map - get value with const key - c++

Question

I have an unordered map that uses a pointer to a custom object as key.
For some reason looking up the values with the key only works if the key is not const.
Here is an example (with std::string as stand-in for the custom object):
std::unordered_map<std::string*, int> my_map;
std::string key {"test"};
const std::string const_key {"test2"};
auto value = my_map.at(&key); // this works as expected
auto other_value = my_map.at(&const_key); // this doesn't compile
error: invalid conversion from 'const string* {aka const std::__cxx11::basic_string<char>*}'
to 'std::unordered_map<std::__cxx11::basic_string<char>*, int>::key_type
{aka std::__cxx11::basic_string<char>*}' [-fpermissive]
Why would a lookup require the pointer to be non const?

Answer 1

When you write &const_key this evaluates to const std::string *, but your map uses std::string * as key type.
There is a difference between "address to string" and "address to a string that is const". Therefore these are considered different types, and you cannot use them interchangeably.
P.S. Could not write this as comment, so posted as answer.

Answer 2

thought I would offer a little more reasoning as to why this is going on (I ran into the same problem... grumble grumble grumble).
Consider the following code:
template <typename T>
void f(T t) { *t += 1; }
int main() {
const int x = 0;
//f<int*>(&x); //error: no matching function for call to ‘f<int*>(const int*)’
//f(&x); //error: assignment of read-only location ‘* t’
int y = 0;
f<int*>(&y); //okay, what we're "supposed" to do
int * const z_p = &y;
f(z_p); //okay, we'll copy z_p by value and modify y
}
In this (somewhat minimal) example, we can clearly see why we can't take a const int * as an argument to our function f(int *). If we did, we could modify it (not good). This covers the no matching function call, but in the second case we get through the template deduction with no problems, but hit a wall when we try to modify our value (that's not the template functions fault, you are using it wrong!) The third case is boring and expected, and I threw in the fourth case just to remind those of you who, like me, get confused with funny pointer types.
If you are sure of that the function you are calling won't modify your thing, or you are an international man of mystery, then there is always the option to cast your pointer.
f<int*>((int*)&x); //that's just lazy
f<int*>(const_cast<int*>(&x)); //that's just crazy
In this specific example, the results of the code above are undefined. I ran it on my machine with g++ --std=c++14 -g -O0 -Wall and got about what I expected, the value of x didn't change a bit. Today we were playing around with this situation and found that because this is undefined behavior, the compiler is allowed to optimize out the const value read from the object code. Note that x still exists on the stack, and you can modify that place in memory like you would any other, but when you read it the initial value will likely just be given by the compiler. Finally, if you move the definition of x to global scope, then you may very well have a segfault if you cast away the const-ness and modify the location in memory.
In general, I find the confusion somewhat justified, because the std::unordered_map<Key,T>::value_type is std::pair<const Key, T> (https://en.cppreference.com/w/cpp/container/unordered_map). In my mind I sort of thought "oh, then I can just shove a const whatever in there and it'll all work out." Then I found this post and scratched my head for a second, thought of the above example, and once again found that the language is protecting me from my funny self. Sigh...
For more reading on the matter, see: https://en.cppreference.com/w/cpp/language/template_argument_deduction.

Answer 3

The map is declared like
std::unordered_map<std::string*, int> my_map;
^^^^^^^^^^^^
You are truing to call the method at with a key of type const std::string *
auto other_value = my_map.at(&const_key);
^^^^^^^^^^
There is no implicit conversion from the type const std::string * to the type std::string *.
You could for example declare the map like
std::unordered_map<const std::string *, int> my_map;
and in this case both arguments std::string * and const std::string * could be used.