我需要一个std::unordered_map
密钥为std::pair<T*, T*>
,所以我“偷”了以下代码:
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;
}
};
}
来自此stackoverflow answer。
它在linux机器上的魅力就像gcc 4.9.2一样。但是在Windows visual studio 2012中,它在调用find()
的成员函数unordered_map
时崩溃了。我的一个朋友在Windows机器上调试了崩溃,他报告说它只是在调试编译模式下通过给出“向量下标超出范围”而中断。
std::pair<T*, T*>
?std::pair<T*, T*>
?P.S:非常抱歉没有张贴mcve但是不可能这样做。
答案 0 :(得分:3)
std
中std
类型中模板的专业化可能会或可能不会使您的程序格式错误(标准不明确,似乎使用&#34;用户定义的类型&# 34;以多种不同的方式,没有定义它)。请参阅my question on the subject和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<>
作为你的哈希传递给一个容器,你不必做一个粗略的事情,即为{{1}中的一个类型(主要)提供std
专门化}}
std
存在,因此您可以进行SFINAE测试(例如,检测类型是否类似于容器,并转发到my_hash::hasher<?,void>
。hash_container
提供类型的ADL覆盖,而不必傻瓜在my_hash::hash
命名空间中。
举个例子:
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);
}
};
现在可以播放了。不需要杂乱的专业化。