如何检测具有特定签名的静态成员函数的存在？

Question

我发现了几个关于在编译时（通过 SFINAE）检测给定类是否具有特定名称、类型或签名的成员的 SO 问题和答案。但是，我找不到一个也适用于 static public 成员函数的函数（当指向成员的技巧不起作用时）。有什么想法吗？

Answer 1

以下可能会有所帮助：(https://ideone.com/nDlFUE)

#include <cstdint>

#define DEFINE_HAS_SIGNATURE(traitsName, funcName, signature)               \
    template <typename U>                                                   \
    class traitsName                                                        \
    {                                                                       \
    private:                                                                \
        template<typename T, T> struct helper;                              \
        template<typename T>                                                \
        static std::uint8_t check(helper<signature, &funcName>*);           \
        template<typename T> static std::uint16_t check(...);               \
    public:                                                                 \
        static                                                              \
        constexpr bool value = sizeof(check<U>(0)) == sizeof(std::uint8_t); \
    }

然后定义一个特征：

DEFINE_HAS_SIGNATURE(has_foo, T::foo, void (*)(void));

Answer 2

这是一种方法：

#include <type_traits>

template<typename, typename>
struct has_fun;

template<typename T, typename Ret, typename... Args>
struct has_fun<T, Ret(Args...)> {
    template<typename U, U> struct Check;

    template<typename U>
    static std::true_type Test(Check<Ret(*)(Args...), &U::fun>*);

    template<typename U>
    static std::false_type Test(...);

    static const bool value = decltype(Test<T>(0))::value;
};

它是为一个名为fun 的函数编写的。像has_fun<T, int(int, int)>::value一样使用它。

这是另一个：

#include <type_traits>

template<typename, typename>
struct has_fun;

template<typename T, typename Ret, typename... Args>
struct has_fun<T, Ret(Args...)> {

    struct No {}; // need a unique type for the second overload
                  // so it doesn't match Ret and give a false positive
    template<typename U>
    static auto Test(int) -> decltype( U::fun(std::declval<Args>()...) );

    template<typename U>
    static No Test(...);

    static const bool value =
        std::is_same<decltype(Test<U>(0)), Ret>{};
};

测试函数的返回类型是否可转换为Ret 而不是检查exatch 匹配可能是明智的。在这种情况下使用is_convertible 而不是is_same，同时检查返回类型是否不同于No（如Yakk points out，那里有几乎可以从任何东西构造的类型） .

Answer 3

只需调用成员函数并丢弃 SFINAE 上下文中的结果。如果成功，则该方法存在。如果失败，则方法不会。

// not needed in C++1y
template<class T,class V=void>using enable_if_t=typename enable_if<T,V>::type;

// If the other tests fail, the type T does not have a method `foo` of
// signature Sig.  The class=void parameter is an implementation detail
// that in an industrial quality implementation we would hide in a helper
// template type.
template<class T,class Sig,class=void>struct has_foo:std::false_type{};

// For R(Args...), we attempt to invoke `T::foo` with (Args...), then check
// if we can assign the return value to a variable of type R.
template<class T,class R,class...Args>
struct has_foo<T,R(Args...),
  enable_if_t< // std:: in C++1y
    std::is_convertible<
      decltype( T::foo( std::declval<Args>()... ) ),
      R
    >::value
    && !std::is_same<R, void>::value
  >
>: std::true_type {};
// for `void` return value, we only care if the function can be invoked,
// no convertible test required:
template<class T,class...Args>
struct has_foo<T,void(Args...),
  decltype( void(T::foo( std::declval<Args>()... ) ) )
>: std::true_type {};

使用：

 has_foo< bar, int(int) >::value

它检查int r = T::foo( 7 ) 是否是一个有效的表达式，而不是精确的签名匹配。