unordered_map::find 键 std::pair 的指针与自定义散列在 VS2012 中崩溃

Question

我需要 std::unordered_map 键 std::pair<T*, T*> 所以我 "stole" 下面的代码：

template <class T>
inline void hash_combine(std::size_t & seed, const T & v)
{
  std::hash<T> hasher;
  seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}

namespace std
{
  template<typename S, typename T> struct hash<pair<S, T>>
  {
    inline size_t operator()(const pair<S, T> & v) const
    {
      size_t seed = 0;
      ::hash_combine(seed, v.first);
      ::hash_combine(seed, v.second);
      return seed;
    }
  };
}

来自这个 Whosebug answer。

它在装有 gcc 4.9.2 的 linux 机器上工作得很好。然而，在 windows visual studio 2012 年，它在调用我的 unordered_map 的成员函数 find() 时崩溃。我的一个朋友调试了 windows 机器上的崩溃，他报告说它只在调试编译模式下通过给 "vector subscript out of range".

中断

问：

发布的代码对散列 a std::pair<T*, T*> 有效吗？
是否有更多 robust/better 散列 std::pair<T*, T*> 的方法？
是什么导致了这种奇怪的行为？

P.S: 非常抱歉没有发帖 mcve 但这是不可能的。

Answer 1

std 中的模板特化也适用于 std 中的类型可能会也可能不会使您的程序格式错误（标准不明确，似乎在多个 "user-defined type" 中使用不同的方式而无需定义它）。参见 my question on the subject, and active working group defect on the issue。

因此创建您自己的哈希命名空间：

namespace my_hash {
  template<class T=void,class=void>
  struct hasher:std::hash<T>{};

  template<class T, class=std::result_of_t< hasher<T>(T const&) >>
  size_t hash( T const& t ) {
    return hasher<T>{}(t);
  }
  template<>
  struct hasher<void,void> {
    template<class T>
    std::result_of_t<hasher<T>(T const&)>
    operator()(T const& t)const{
      return hasher<T>{}(t);
    }
  };

  // support for containers and tuples:
  template <class T>
  size_t hash_combine(std::size_t seed, const T & v) {
    seed ^= hash(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
    return seed;
  }

  template<class Tuple, size_t...Is>
  size_t hash_tuple_like(Tuple const& t, size_t count, std::index_sequence<Is...>) {
    size_t seed = hash(count);
    using discard=int[];
    (void)discard{0,((
      seed = hash_combine(seed, std::get<Is>(t))
    ),void(),0)...};
    return seed;
  }
  template<class Tuple>
  size_t hash_tuple_like(Tuple const& t) {
    constexpr size_t count = std::tuple_size<Tuple>{};
    return hash_tuple_like(t, count, std::make_index_sequence<count>{} );
  }
  struct tuple_hasher {
    template<class Tuple>
    size_t operator()(Tuple const& t)const{
      return hash_tuple_like(t);
    }
  };
  template<class...Ts>
  struct hasher<std::tuple<Ts...>,void>:
    tuple_hasher
  {};
  template<class T, size_t N>
  struct hasher<std::array<T,N>,void>:
    tuple_hasher
  {};
  template<class...Ts>
  struct hasher<std::pair<Ts...>,void>:
    tuple_hasher
  {};
  template<class C>
  size_t hash_container( C const& c ) {
    size_t seed = hash(c.size());
    for( const auto& x:c ) {
      seed = hash_combine( seed, x );
    }
    return seed;
  }
  struct container_hasher {
    template<class C>
    size_t operator()(C const& c)const{ return hash_container(c); }
  };
  template<class...Ts>
  struct hasher< std::vector<Ts...>, void >:
    container_hasher
  {};
  // etc
};

现在您将 my_hash::hasher<> 作为您的散列器传递给容器，并且您不必为 std 中的类型（主要）提供 std 专门化的粗略业务=].

my_hash::hasher<?,void> 存在，因此您可以进行 SFINAE 测试（例如，检测类型是否类似于容器，然后转发到 hash_container。my_hash::hash 为类型提供 ADL 覆盖，而无需在 my_hash 命名空间中闲逛。

举个例子：

template<class T>
struct custom {
  std::vector<T> state;
  friend size_t hash( custom const& c ) {
    using my_hash::hash;
    return hash(state);
  }
};

和 custom 现在可以哈希了。不需要混乱的专业化。

unordered_map::find 键 std::pair 的指针与自定义散列在 VS2012 中崩溃

unordered_map::find with key std::pair of pointers with custom hash crashes in VS2012

c++

unordered-map

c++11

visual-studio-2012

stdhash

问：