c++ - 如何使用 type_traits 生成依赖于类特化是否存在的代码？

Question

背景

我正在尝试写一个 class template Hasher这将以两种不同的方式实现，具体取决于是否 std::hash<T>已为 T 实现:

template<typename T>
struct Hasher
{
  std::size_t hash( T t ) const;
  // implement as A { std::hash<T> h; return h( t ); }
  //           or B { std::hash<std::string> h; return h( t.to_string() );  }
};

如果std::hash<T>已经专精了，想用。如果没有，我希望 T有一个to_string()函数返回一个 key 供我哈希。

例如，根据cppreference , 如果 T是long long 、指针或 std::string ，我想要版本 A。如果它不是列出的那些标准版本之一，并且如果用户没有专门化 std::hash<T>对于他自己的类型，我期望 T有一个std::string to_string() const给我打电话。在这种情况下，我想生成版本 B。

问题

如何使用 C++11/type_traits/no-SFINAE 生成正确的实现？

附录

另一种思考方式:

这几乎就像我希望版本 B 成为默认行为(即，如果不存在专门化，则使用版本 B)。

已测试 NAWAZ 的解决方案

我刚刚在 gcc 4.8.1 上试用了 Nawaz 的解决方案，因为他的解决方案排在第一位，实际上对我来说是最容易阅读和理解的(更重要)。

#include <functional>
#include <cassert>

template<typename T>
class Hasher
{
        // overloading rules will select this one first...  ...unless it's not valid
        template<typename U>
        static auto hash_impl(U const& u, int)
                -> decltype(std::hash<U>().operator()( u ))
        {
                 return std::hash<U>().operator()( u );
        }
        // as a fallback, we will pick this one
        template<typename U>
        static auto hash_impl(U const& u, ... )
                -> std::size_t
        {
                 return std::hash<std::string>().operator()(u.to_string());
        }

public:
        auto hash( T t ) const -> decltype( hash_impl(t,0) )
        {
                 return hash_impl( t, 0 );
        }
};

struct Foo
{
        std::string  m_id;
        std::string  to_string() const { return m_id; }
};

int
main( int argc, char** argv )
{
        std::string        s{ "Bar" };
        Foo                f{ s     };
        long long          l{ 42ll  };

        Hasher<long long>   hl;
        Hasher<Foo>         hf;
        Hasher<std::string> hs;

        assert( hl.hash( l )==l );
        assert( hf.hash( f )==hs.hash( s ));

        return 0;
}

经过测试的 DANIEL FREY 的解决方案

Daniel 的实现也很有趣。通过首先计算我们是否有散列，我可以使用 tag-dispatch 来选择我想要的实现。我们有一个很好的模式/关注点分离，这导致了非常干净的代码。

然而，在执行has_hash<> , decltype 的参数一开始我很困惑。事实上，它不应该被解读为争论。相反，它是一个表达式列表(逗号分隔的表达式)。我们需要遵守表达的规则 here .

C++ ensures that each of the expressions is evaluated and its side effects take place. However, the value of an entire comma-separated expression is only the result of the rightmost expression.

此外，使用 void()起初对我来说是个谜。当我将其更改为 double()看看会发生什么，很明显为什么它真的应该是void() (所以我们不需要传入第二个模板参数)。

#include <functional>
#include <cassert>

template< typename, typename = void >
struct has_hash
  : std::false_type {};

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

template<typename T>
class Hasher
{
        static std::size_t hash_impl(T const& t, std::true_type::type )
        {
                 return std::hash<T>().operator()( t );
        }

        static std::size_t hash_impl(T const& t, std::false_type::type )
        {
                 return std::hash<std::string>().operator()(t.to_string());
        }

public:
        std::size_t hash( T t ) const
        {
                 return hash_impl( t, typename has_hash<T>::type() );
        }
};

struct Foo
{
        std::string  m_id;
        std::string  to_string() const { return m_id; }
};

int
main( int argc, char** argv )
{
        std::string        s{ "Bar" };
        Foo                f{ s     };
        long long          l{ 42ll  };

        Hasher<long long>   hl;
        Hasher<Foo>         hf;
        Hasher<std::string> hs;

        assert( hl.hash( l )==l );
        assert( hf.hash( f )==hs.hash( s ));

        return 0;
}

Answer 1

您可以使用 C++11 引入的 Expression SFINAE。

这是一个如何实现的例子:

template<typename T>
struct Hasher
{
    auto hash( T t ) const -> decltype(hash_impl(t,0))
    {
       return hash_impl(t, 0);
    }
  private:
    template<typename U>
    static auto hash_impl(U const & u, int) -> decltype(std::hash<U>().hash(u))
    {
       return std::hash<U>().hash(u);
    }
    template<typename U>
    static auto hash_impl(U const & u, ... ) -> std::string
    {
       return u.to_string();
    }
};

请注意 hash_impl是一个重载的函数模板。所以当你这样写的时候:

       return hash_impl(t, 0); 

自从第二个参数0是int ，上面的第一次尝试调用hash_impl使用std::hash — 如果 std::hash<U>().hash(u)，此尝试可能会失败不是有效的表达式(表达式 SFINAE)。如果失败，则第二个 hash_impl被调用。