Как найти по константному ключу указателя на карте с неконстантными ключами указателя

Ключ в карте семантически неизменен, все операции карты, которые разрешают прямой доступ к ключам, делают это путем const-квалификации типа ключа (например, value_type определяется как pair<const Key, T>).

Однако в случае типа ключа int* вы получите указатель const на неконстантный int (int*const), что не очень приятно (он по-прежнему работает, поскольку в качестве значения используется только значение указателя). key, но семантика неизменяемости размывается, что может привести к ошибкам).

Вместо того, чтобы отказываться от константности, просто измените map на map<const int*, double>.

Тогда он будет работать как для const int*, так и для int* ключей.

#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
}

Попробуйте const_cast, который позволяет изменить постоянство (или изменчивость) переменной.

#include <map>

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

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

Я думаю, что нашел решение, но для него требуются прозрачные компараторы С++ 14.

#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()
}

Отличную статью о прозрачных компараторах C++14 можно найти здесь. Честно говоря, добавив компаратор, немного изменился тип mymap, чего я изначально не хотел, но это лучшее решение, которое я смог найти.

Если C++14 недоступен, есть по крайней мере два зла, из которых мы можем выбирать. Первый — скопировать mymap в новый std::map<const int*, double> в myfind, что ужасно неэффективно. Второй — отбрасывание константы с помощью const_cast<int*>(mykey), который должен быть избегайте, если это возможно.

У вас может быть проблема с константной правильностью. const int * может быть не тем, что вы думаю, что это. Это указатель на константу целое число. Это не то же самое, что тип ключа вашей карты, который представляет собой указатель на (непостоянное) целое число. И ни один из них не совпадает с int * const, который является постоянным указателем на (непостоянное) целое число. Проблема не в том, является ли само значение ключа изменяемым или неизменным, а в том, являются ли вещи, на которые вы храните указатели, изменяемыми или неизменяемыми.

Например, это компилируется:

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

Как и это:

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;
}

Вы видите разницу? В вашем исходном коде компилятор совершенно правильно отмечает ошибку. Если ваша функция принимает const int *, то вы, по сути, обещаете не изменять int, на который указывает указатель, который я передаю. Но если вы используете такой указатель, как int * в ключе std::map, вы можете позволить кому-то изменить что int.

В этом конкретном случае мы знаем, что std::map::find() не будет назначаться аргументу указателя, но компилятор этого не делает, поэтому const_cast<> существует, как указано в других ответах.