unordered_map 哈希函数返回

Question

我想要一个unordered_map 和一个struct，我想用作多个std::set< std::string > 的键。

我看到一个自定义哈希函数is required 并且一个字符串可以应用std::hash；但是，我无法确定应该返回什么来满足 unordered_map 的这些集合的哈希函数的目的。

自定义散列函数应该如何返回？

Answer 1

我认为这可能是Snps' answer 的更好选择。这为用户定义的类型实现了 std::hash 的特化，它在不创建临时字符串的情况下对结构进行哈希处理。

我从 Boost 中复制了两个函数 hash_combine 和 hash_range，以计算来自两个容器的单个哈希值。

#include <iostream>
#include <functional>
#include <set>
#include <unordered_map>

// user-defined type
struct myStruct {
    std::set<std::string> s1;
    std::set<std::string> s2;

    bool operator==(const myStruct &other) const {
        return (s1 == other.s1) && (s2 == other.s2);
    }
};

// hash helper functions plagiarized from Boost
template <typename T>
void hash_combine(size_t &seed, const T &v)
{
    using std::hash;
    seed ^= hash<T>()(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}

template <typename It>
void hash_range(size_t &seed, It first, It last)
{
    for (; first != last; ++first) {
        hash_combine(seed, *first);
    }
}

// std::hash specialization
namespace std
{
    template<> struct hash<myStruct> {
        size_t operator()(const myStruct &key) const {
            size_t seed = 0;
            hash_range(seed, key.s1.begin(), key.s1.end());
            hash_range(seed, key.s2.begin(), key.s2.end());
            return seed;
        }
    };
}

int main()
{
    std::unordered_map<myStruct, int> myMap;

    myStruct ms1{ { "apple", "pear", "orange" }, { "red", "green", "blue" } };
    myStruct ms2{ { "pear", "apple", "orange" }, { "red", "green", "blue" } };
    myStruct ms3{ { "apple", "banana", "orange" }, { "red", "green", "blue" } };

    myMap[ms1] = 1;
    myMap[ms2] = 2;
    myMap[ms3] = 3;

    std::cout << myMap.size() << '\n'; // output: 2
}

Answer 2

std::hash的要求如下：(http://en.cppreference.com/w/cpp/utility/hash)

哈希模板定义了一个实现哈希函数的函数对象。该函数对象的实例满足 Hash。特别是，他们定义了一个 operator()：

1. 接受Key 类型的单个参数。
2. 返回一个size_t 类型的值，表示参数的哈希值。
3. 调用时不抛出异常。
4. 对于两个相等的参数k1 和k2，std::hash<Key>()(k1) == std::hash<Key>()(k2)。
5. 对于两个不同的参数k1和k2不相等，std::hash<Key>()(k1) == std::hash<Key>()(k2)的概率应该很小，接近1.0 / std::numeric_limits<size_t>::max()。

哈希模板既是CopyConstructible又是Destructible。

所以你需要的基本上是一个函数，它返回一个std::size_t，它对于每个myStruct 对象都是唯一的，并且对于被认为是等效的对象返回相同的值。

编辑：以下可能不是生成哈希的最可靠的方法，但它将作为如何完成它的基本示例。

一种方法是使用 std::hash<std::string> 的标准特化，通过使用 分隔符序列 连接每个 std::set 成员中的所有字符串，然后将所有生成的合并字符串连接成一个并使用标准哈希函数返回哈希值。

如果成员 std::sets 不同，则合并的“超级”字符串对于每个 myStruct 对象都是唯一的，并且当成员不不同时仍然相同，因为 std::set 是有序容器。

struct myStruct {
    std::set<std::string> s1;
    std::set<std::string> s2;
};

std::string mergeAllStrings(const myStruct& ms) {
    static const std::string SEPARATOR = "#¤%&"; // Some uncommon sequence.
    std::string super;
    for (const auto& s : ms.s1) {
        super += s + SEPARATOR; // Append separator.
    }
    for (const auto& s : ms.s2) {
        super += s + SEPARATOR; // Append separator.
    }
    return super;
}

int main() {
    myStruct ms1{{"apple", "pear", "orange"}, {"red", "green", "blue"}};
    myStruct ms2{{"pear", "apple", "orange"}, {"red", "green", "blue"}};
    myStruct ms3{{"apple", "banana", "orange"}, {"red", "green", "blue"}};

    std::cout << std::hash<std::string>()(mergeAllStrings(ms1)) << std::endl;
    std::cout << std::hash<std::string>()(mergeAllStrings(ms2)) << std::endl;
    std::cout << std::hash<std::string>()(mergeAllStrings(ms3)) << std::endl;
}

输出：

2681724430859750844 // Same
2681724430859750844 // Same
2942368903851914580 // Different

您现在可以创建一个哈希函子，例如如：

struct MyHash {
    std::size_t operator()(const myStruct& ms) const {
        return std::hash<std::string>()(mergeAllStrings(ms));
    }
};

并将其与std::unordered_map 一起使用：

std::unordered_map<myStruct, myValue, MyHash> m;

请注意，您还应该提供自定义的 equal_to 函子。