How to find by a const pointer key in a map with non-const pointer keys

Question

The following C++ code does not compile because it's passing a non-const pointer to a find() function which expects a const pointer.

#include <map>

std::map<int*, double> mymap;

double myfind(const int * mykey)
{
    return mymap.find(mykey)->second;
}

Is there a way how to make the finding work without changing the type of the map or making variable mykey non-const? After all the function find() does not modify the pointed object, it just compares the pointers.

Answer 1

I think I have found a solution, but it requires C++14 transparent comparators.

#include <map>
#include <iostream>

struct CompareIntPtrs
{
    using is_transparent = void; // enabling C++14 transparent comparators

    bool operator()(const int * l, const int * r) const
    {
        return l < r;
    }
};

std::map<int*, double, CompareIntPtrs> mymap;

double myfind(const int * key)
{
    return mymap.find(key)->second;
}

int main()
{
    int x {6};
    mymap[&x] = 66; // inserting to the map
    const int * px = &x; // creating a "const int *" variable

    std::cout << myfind(px) << std::endl; // using "const int *" for finding in map with "int*" keys
    std::cout << mymap.find(px)->second << std::endl; // we could even skip using myfind()
}

An excellent article about C++14 transparent comparators can be found here. To be completely honest, by adding the comparator, the type of mymap slightly changed which I originally didn't want to, but it's the best solution I could find.

If C++14 is not available, there are at least two evils we can choose from. The first one is to copy mymap to a new std::map<const int*, double> in myfind, which is horribly unefficient. The second one is casting away constness by using a const_cast<int*>(mykey) which should be avoided if possible.

Answer 2

Try const_cast which allows you to change constness (or volatility) of variable.

#include <map>

std::map<int*, double> mymap;

double myfind(const int * mykey)
{
    return mymap.find(const_cast<int*>(mykey))->second;
}

Answer 3

A key in a map is semantically immutable, all map operations that allow direct access to keys do that by const-qualifying the key type (e.g. value_type is defined as pair<const Key, T>).

In case of int* key type however you'd get a const pointer to non-const int (int*const), which isn't very nice (it still works, since only the pointer value is used as the key, but the semantics of immutability become diluted, which can lead to bugs).

Instead of casting away constness, just change the map to map<const int*, double>.

Then it will work for const int* as well as int* keys.

#include <map>

std::map<const int*, double> mymap;

double myfind(const int * mykey)
{
    return mymap.find(mykey)->second; // just works
}

double myfind(int * mykey)
{
    return mymap.find(mykey)->second; // also works
}

Answer 4

You may have a const-correctness issue. const int * may not be what you think it is. It is a pointer to a constant integer. This is not the same as the key type of your map, which is a pointer to a (non-constant) integer. And neither are the same as int * const which is a constant pointer to a (non-constant) integer. The issue isn't whether the key value itself is mutable or immutable, it's whether the things you're storing pointers to are mutable or immutable.

For example, this compiles:

std::map<int *, double> mymap;
double myfind(int * const mykey) {
    return mymap.find(mykey)->second;
}

As does this:

std::map<const int *, double> mymap;
double myfind(const int *mykey) {
    return mymap.find(mykey)->second;
}
double myfind2(const int * const mykey) {
    return mymap.find(mykey)->second;
}

Do you see the difference? In your original code, the compiler is quite right to flag an error. If your function takes a const int *, then you are in effect promising not to modify the int pointed to by the pointer I pass in. But if you use such a pointer as int * in the key of a std::map, you may be allowing someone to modify that int.

In this particular case, we know that std::map::find() will not assign to a pointer argument, but the compiler doesn't, which is why const_cast<> exists as pointed out in other answers.