如何专门化std :: hash <T> 用户定义的类型？

Question

问题

对于用户定义类型的std :: unordered_map或std :: unordered_set的第三个模板参数，std :: hash有什么好的特殊性，所有成员数据类型都已经具有良好的std :: hash特性？

对于这个问题，我将“好”定义为易于实现和理解，合理有效，并且不太可能产生哈希表冲突。 商品的定义不包括任何有关安全性的陈述。

什么是谷歌的状态

目前，两个StackOverflow问题是Google搜索“std hash specialization”的第一个问题。

第一个， 如何在无序容器中为用户定义的类型专门化std :: hash :: operator（）？ ，解决了打开std命名空间和添加模板特化是否合法的问题。

第二个， 如何专门化来自其他库的类型的std :: hash ，基本上解决了同样的问题。

这留下了当前的问题。 鉴于C ++标准库的实现为标准库中的基本类型和类型定义了散列函数，为用户定义的类型专门化std :: hash的简单有效方法是什么？ 有没有一种很好的方法来组合标准库实现提供的哈希函数？

（编辑感谢dyp。）StackOverflow的另一个问题是如何组合一对哈希函数。

谷歌的其他结果没有任何帮助。

这篇 Dobbs博士的文章指出，两个令人满意的哈希的XOR将产生一个新的令人满意的哈希值。

这篇文章似乎是从知识中说出并暗示了很多东西，但却注重细节。 它与第一个例子中的简短评论中的Dr. Dobbs文章相矛盾，称使用XOR组合散列函数会产生一个弱的结果散列函数。

因为XOR应用于任何两个相等的值导致0，我可以看出为什么XOR本身很弱。

元问题

一个很好的理由回答解释为什么这个问题无效且一般无法回答也是受欢迎的。

Answer 1

一种简单的方法是使用boost::hash库并为您的类型扩展它 。 它有一个很好的扩展函数hash_combine （ std::hash缺少），可以轻松组合结构中各个数据成员的哈希值。

换一种说法：

1. 为您自己的类型重载boost::hash_value 。
2. 为您自己的类型专门化std::hash并使用boost::hash_value实现它。

通过这种方式，您可以获得最好的std和boost世界， std::hash<>和boost::hash<>适用于您的类型。

---

更好的方法是在N3980类型不知道＃中使用建议的新散列基础设施。 这种基础结构使得hash_combine不必要。

Answer 2

首先，Dobbs博士的文章说，两个令人满意的哈希的XOR将产生令人满意的哈希是完全错误的。 这是贫穷哈希的好方法。 通常，要创建一个好的哈希，首先要将对象分解为子对象，每个对象都存在一个好的哈希，并组合哈希。 一种简单的方法是这样的：

class HashAccumulator
{
    size_t myValue;
public:
    HashAccumulator() : myValue( 2166136261U ) {}
    template <typename T>
    HashAccumulator& operator+=( T const& nextValue )
    {
        myValue = 127U * myValue + std::hash<T>( nextHashValue );
    }
    HashAccumulator operator+( T const& nextHashValue ) const
    {
        HashAccumulator results( *this );
        results += nextHashValue;
        return results;
    }
};

（这个被设计成如果你有一系列值，你可以使用std::accumulate 。）

当然，这假设所有子类型都具有良好的std::hash 。 对于基础类型和字符串，这是给定的; 对于您自己的类型，只需递归地应用上述规则，专门使用std::hash在其子类型上使用HashAccumulator 。 对于基本类型的标准容器，它有点棘手，因为您（正式地，至少）不允许在标准库的类型上专门化标准模板; 你可能必须创建一个直接使用HashAccumulator的类，并明确指定如果你需要这样一个容器的哈希。

Answer 3

在我们获得标准库以帮助解决此问题之前：

1. 下载一个现代的哈希，如SpookyHash： http ：//burtleburtle.net/bob/hash/spooky.html。
2. 在定义std::hash<YourType>创建一个SpookyHash实例， Init它。 请注意，在进程启动或std::hash构造中选择一个随机数，并将其用作初始化将使您的程序执行起来稍微困难，但不能解决问题 。
3. 获取结构中有助于operator== （“显着字段”）的每个字段，并将其提供给SpookyHash::Update 。
   • 当心类型，如double ：他们有2所申述char[]是比较== ： -0.0和0.0 。 还要注意具有填充的类型。 在大多数机器上， int没有，但是很难判断struct是否会。 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3980.html#is_contiguously_hashable讨论了这一点。
   • 如果你有子结构，你将通过递归地将它们的字段输入到同一个SpookyHash实例中来获得更快，更高质量的哈希值。 但是，这需要向这些结构添加方法或手动提取显着字段：如果您不能这样做，只需将其std::hash<>值提供给顶级SpookyHash实例即可。
4. 从std::hash<YourType>返回SpookyHash::Final的输出。

Answer 4

您的操作是必需的

• 返回size_t类型的值
• 与==运算符一致。
• 对于不相等的值，哈希冲突的概率很低。

没有明确要求散列值均匀分布在size_t整数范围内。 cppreference.com指出

[标准库]的一些实现使用简单（标识）散列函数，其将整数映射到其自身

避免散列冲突加上这个弱点意味着你的类型的std::hash应该永远不会简单地使用（快速）按位XOR（ ^ ）来组合数据成员的子散列。 考虑这个例子：

 struct Point {
    uint8_t x;
    uint8_t y;
 };

 namespace std {
    template<>
    struct hash< Point > {
       size_t operator()(const Point &p) const {
          return hash< uint8_t >(p.x) ^ hash< uint8_t >(p.y);
       }
    };
 }

px的哈希值将在[0,255]范围内， py的哈希值也是如此。 因此， Point的散列也将在[0,255]范围内，具有256（= 2 ^ 8）个可能的值。 有256 * 256（= 2 ^ 16）个唯一的Point对象（ std::size_t通常支持2 ^ 32或2 ^ 64个值）。 因此， 良好散列函数的哈希冲突概率应约为2 ^（ - 16）。 我们的函数给出了小于2 ^（ - 8）的哈希冲突的概率。 这很糟糕：我们的哈希只提供8位信息，但好的哈希应提供16位信息。

如果数据成员的散列函数仅在std::size_t范围的低部分提供散列值，则必须在组合之前“移位”组件散列的位，因此它们各自提供独立的信息位。 做左移是很简单的

       return (hash< uint8_t >(p.x) << 8) ^ hash< uint8_t >(p.y);

但是如果hash< uint8_t > （在这种情况下）的实现试图在std::size_t范围内扩展哈希码值，那将丢弃信息（由于溢出）。

使用乘法加法和加法的方法累积组件哈希码值， 通常在Java中完成 ， 通常可能效果更好：

 namespace std {
    template<>
    struct hash< Point > {
       size_t operator()(const Point &p) const {
          const size_t prime = 257;
          size_t h {hash< uint8_t >(p.x)};
          h = h * prime + hash< uint8_t >(p.y);
          return h;
       }
    };
 }