c++ - 检查类型是否可散列

Question

我想创建一个类型特征，以使用标准库的无序容器的默认实例化检查特定类型是否可散列，因此它是否具有 std::hash 的有效特化.我认为这将是一个非常有用的功能(例如，在通用代码中使用 std::set 作为 std::unordered_set 的故障保护)。所以我想std::hash没有为每种类型定义，开始制作以下SFINAE解决方案:

template<typename T> std::true_type hashable_helper(
    const T&, const typename std::hash<T>::argument_type* = nullptr);

template<typename T> std::false_type hashable_helper(...);

//It won't let me derive from decltype directly, why?
template<typename T> struct is_hashable 
    : std::is_same<decltype(hashable_helper<T>(std::declval<T>())),
                   std::true_type> {};

(如果这不是最佳解决方案甚至是错误的，请原谅我的 SFINAE 能力不足。)

但后来我了解到，gcc 4.7 和 VC++ 2012 都定义了 std::hash对于任何类型T , 只是 static_assert在非专业版本中学习。但不是有条件地编译它们(以及使用 gcc 4.7 的 libstdc++ 的 clang 3.1)使断言失败，从而导致编译错误。这似乎是合理的，因为我认为 static_assert s 不由 SFINAE 处理(对吗？)，因此 SFINAE 解决方案似乎根本不可能。 gcc 4.6 的情况更糟甚至没有 static_assert一般std::hash模板，但只是没有定义它的()运算符，在尝试使用它时导致链接器错误(这总是比编译错误更糟糕，我无法想象有任何方法可以将链接器错误转换为编译器错误)。

如果类型具有有效的std::hash，那么是否有任何符合标准且可移植的方式来定义返回的这种类型特征？特化，或者至少对于图书馆 static_assert在通用模板中输入(以某种方式将 static_assert 错误转换为 SFINAE 非错误)？

Answer 1

从 C++17 开始，现在可以以更优雅的方式执行此操作。来自 cppreference关于 std::hash:

Each specialization of this template is either enabled ("untainted") or disabled ("poisoned"). For every type Key for which neither the library nor the user provides an enabled specialization std::hash, that specialization exists and is disabled. Disabled specializations do not satisfy Hash, do not satisfy FunctionObject, and std::is_default_constructible_v, std::is_copy_constructible_v, std::is_move_constructible_v, std::is_copy_assignable_v, std::is_move_assignable_v are all false. In other words, they exist, but cannot be used.

这意味着 STL 必须在 C++17 中删除 static_assert。这是使用“Clang-6.0.0 -std=c++17”的有效解决方案:

#include <functional>
#include <ios>
#include <iostream>
#include <type_traits>

template <typename T, typename = std::void_t<>>
struct is_std_hashable : std::false_type { };

template <typename T>
struct is_std_hashable<T, std::void_t<decltype(std::declval<std::hash<T>>()(std::declval<T>()))>> : std::true_type { };

template <typename T>
constexpr bool is_std_hashable_v = is_std_hashable<T>::value; 

struct NotHashable {};

int main()
{
    std::cout << std::boolalpha;
    std::cout << is_std_hashable_v<int> << std::endl;
    std::cout << is_std_hashable_v<NotHashable> << std::endl;
    return 0;
}

这可能会在您使用 boost::hash_combine 时派上用场。或 boost::hash_range .如果您包含包含以下代码示例的 header ，则不再需要为特定类型定义提升哈希。

#include <boost/functional/hash_fwd.hpp>

template <typename T, typename = std::void_t<>>
struct is_boost_hashable : std::false_type { };

template <typename T>
struct is_boost_hashable<T, std::void_t<decltype(boost::hash_value(std::declval<T>()))>> : std::true_type { };

template <typename T>
constexpr bool is_boost_hashable_v = is_boost_hashable<T>::value;  

namespace boost
{
    template <typename T>
    auto hash_value(const T &arg) -> std::enable_if_t<is_std_hashable_v<T> &&
                                                      !is_boost_hashable_v<T>, std::size_t>
    {
        return std::hash<T>{}(arg);
    }
}

注意 is_boost_hashable_v，这是避免歧义所必需的，因为 boost 已经为许多散列提供了散列。