C++ C++；无序映射-没有可行的重载运算符[]

我正在尝试构建一个值备忘录，使用无序的_映射将一对int链接到一个int

int memo(pair<int, int> &p, unordered_map<pair<int, int>, int> &memo) {
    if (memo[p] != -1) {
    }
}

int备忘（配对和p、无序地图和备忘）{
如果（备注[p]！=-1）{
}
}

我想我应该使用pair访问无序_映射中的值，但我得到了一个错误：

“运算符[]”不匹配（操作数类型为“std:：无序映射”和“std:：成对”）

---

您试图使用

std:：pair

作为无序_映射的键，该映射在默认情况下是未定义的，因为std:：pair的哈希没有很好地定义。您需要为

std:：pair

键定义哈希值

链接中的示例：

#include <iostream>
#include <unordered_map>
#include <utility>

typedef std::pair<std::string,std::string> pair;

struct pair_hash
{
    template <class T1, class T2>
    std::size_t operator() (const std::pair<T1, T2> &pair) const
    {
        return std::hash<T1>()(pair.first) ^ std::hash<T2>()(pair.second);
    }
};

int main()
{
    std::unordered_map<pair,int,pair_hash> unordered_map =
    {
        {{"C++", "C++11"}, 2011},
        {{"C++", "C++14"}, 2014},
        {{"C++", "C++17"}, 2017},
        {{"Java", "Java 7"}, 2011},
        {{"Java", "Java 8"}, 2014},
        {{"Java", "Java 9"}, 2017}
    };

    for (auto const &entry: unordered_map)
    {
        auto key_pair = entry.first;
        std::cout << "{" << key_pair.first << "," << key_pair.second << "}, "
                  << entry.second << '\n';
    }

    return 0;
}

#包括
#包括
#包括
typedef std：：对；
结构对散列
{
模板
std:：size\u t运算符（）（常数std:：pair&pair）常数
{
返回std:：hash（）（pair.first）^std:：hash（）（pair.second）；
}
};
int main（）
{
无序映射无序映射=
{
{{“C++”，C++11}，2011}，
{{“C++”，C++14}，2014}，
{{“C++”，“C++17}，2017}，
{{“Java”，“Java 7”}，2011}，
{{“爪哇”，“爪哇8”}，2014}，
{{“爪哇”，“爪哇9”}，2017}
};
用于（自动常量和输入：无序映射）
{
自动密钥对=entry.first；
std:：cout您正试图使用
std:：pair
作为无序_映射的键，该映射在默认情况下未定义，因为std:：pair的哈希没有很好地定义。您需要为
std:：pair
键定义哈希值


链接中的示例：

#include <iostream>
#include <unordered_map>
#include <utility>

typedef std::pair<std::string,std::string> pair;

struct pair_hash
{
    template <class T1, class T2>
    std::size_t operator() (const std::pair<T1, T2> &pair) const
    {
        return std::hash<T1>()(pair.first) ^ std::hash<T2>()(pair.second);
    }
};

int main()
{
    std::unordered_map<pair,int,pair_hash> unordered_map =
    {
        {{"C++", "C++11"}, 2011},
        {{"C++", "C++14"}, 2014},
        {{"C++", "C++17"}, 2017},
        {{"Java", "Java 7"}, 2011},
        {{"Java", "Java 8"}, 2014},
        {{"Java", "Java 9"}, 2017}
    };

    for (auto const &entry: unordered_map)
    {
        auto key_pair = entry.first;
        std::cout << "{" << key_pair.first << "," << key_pair.second << "}, "
                  << entry.second << '\n';
    }

    return 0;
}

#包括
#包括
#包括
typedef std：：对；
结构对散列
{
模板
std:：size\u t运算符（）（常数std:：pair&pair）常数
{
返回std:：hash（）（pair.first）^std:：hash（）（pair.second）；
}
};
int main（）
{
无序映射无序映射=
{
{{“C++”，C++11}，2011}，
{{“C++”，C++14}，2014}，
{{“C++”，“C++17}，2017}，
{{“Java”，“Java 7”}，2011}，
{{“爪哇”，“爪哇8”}，2014}，
{{“爪哇”，“爪哇9”}，2017}
};
用于（自动常量和输入：无序映射）
{
自动密钥对=entry.first；
std:：cout这两个标准容器无法在开箱即用的情况下一起工作真是太令人讨厌了。是的。问题来自std:：map和std:：无序_映射之间的差异。std:：map使用运算符<进行排序，这对于std:：pair来说是定义得很好的，具体取决于其中的类型。然而，std:：无序_映射没有使用运算符<，因为它是无序的，所以它必须依赖于std:：pair的散列，这是没有很好定义的。这两个标准容器无法在开箱即用的情况下一起工作，这非常令人讨厌。是的。问题来自std:：map和std:：unordered_map之间的差异。std:：map使用运算符<进行排序，这是根据类型为std:：pair定义的但是，std:：unordered_map没有使用运算符<，因为它是无序的，所以它必须依赖于std:：pair的散列，该散列没有很好的定义。