c++ - 可调用类成员检测器惯用法和 C++11 final

Question

我想检测一个类型是否可调用，下面的代码适用于所有未标记为 final 的类:

template<typename T>
struct is_callable_impl {
 private:
  typedef char(&yes)[1];
  typedef char(&no)[2];

  struct fallback {
    void operator()();
  };
  struct derived
    : T, fallback {};

  template<typename U, U> struct check;

  template<typename>
  static yes test(...);

  template<typename C>
  static no test(check<void (fallback::*)(), &C::operator()>*);

 public:
   static constexpr bool value = sizeof(test<derived>(0)) == sizeof(yes);
};

template<typename T>
struct is_callable
: std::conditional<
    std::is_function<T>::value,
    std::true_type,
    typename std::conditional<
        std::is_class<T>::value,
        is_callable_impl<T>,
        std::false_type
    >::type
>::type {};

这是 C++03 方式的成员检测器习惯用法，但我们现在可以将 SFINAE 表达式与 decltype 一起使用。我不知道如何检测类型上的任何 重载operator()？上面使用 fallback 来检测 T 上是否没有可用的可调用函数指针。

Live Demo

Answer 1

我愿意

#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(is_callable, T::operator (), void (T::*)() const);

Demo