检查类是否具有给定签名的成员函数

宏(El Diablo!):

CREATE_MEMBER_CHECK:

//Check for any member with given name, whether var, func, class, union, enum.
#define CREATE_MEMBER_CHECK(member)                                         \
                                                                            \
template                             \
struct Alias_##member;                                                      \
                                                                            \
template                                                        \
struct Alias_##member <                                                     \
    T, std::integral_constant::value>  \
> { static const decltype(&T::member) value; };                             \
                                                                            \
struct AmbiguitySeed_##member { char member; };                             \
                                                                            \
template                                                        \
struct has_member_##member {                                                \
    static const bool value                                                 \
        = has_member<                                                       \
            Alias_##member>            \
            , Alias_##member                        \
        >::value                                                            \
    ;                                                                       \
}

CREATE_MEMBER_VAR_CHECK:

//Check for member variable with given name.
#define CREATE_MEMBER_VAR_CHECK(var_name)                                   \
                                                                            \
template                             \
struct has_member_var_##var_name : std::false_type {};                      \
                                                                            \
template                                                        \
struct has_member_var_##var_name<                                           \
    T                                                                       \
    , std::integral_constant<                                               \
        bool                                                                \
        , !std::is_member_function_pointer::value   \
    >                                                                       \
> : std::true_type {}

CREATE_MEMBER_FUNC_SIG_CHECK:

//Check for member function with given name AND signature.
#define CREATE_MEMBER_FUNC_SIG_CHECK(func_name, func_sig, templ_postfix)    \
                                                                            \
template                             \
struct has_member_func_##templ_postfix : std::false_type {};                \
                                                                            \
template                                                        \
struct has_member_func_##templ_postfix<                                     \
    T, std::integral_constant<                                              \
        bool                                                                \
        , sig_check::value                         \
    >                                                                       \
> : std::true_type {}

CREATE_MEMBER_CLASS_CHECK:

//Check for member class with given name.
#define CREATE_MEMBER_CLASS_CHECK(class_name)               \
                                                            \
template             \
struct has_member_class_##class_name : std::false_type {};  \
                                                            \
template                                        \
struct has_member_class_##class_name<                       \
    T                                                       \
    , std::integral_constant<                               \
        bool                                                \
        , std::is_class<                                    \
            typename got_type::type \
        >::value                                            \
    >                                                       \
> : std::true_type {}

CREATE_MEMBER_UNION_CHECK:

//Check for member union with given name.
#define CREATE_MEMBER_UNION_CHECK(union_name)               \
                                                            \
template             \
struct has_member_union_##union_name : std::false_type {};  \
                                                            \
template                                        \
struct has_member_union_##union_name<                       \
    T                                                       \
    , std::integral_constant<                               \
        bool                                                \
        , std::is_union<                                    \
            typename got_type::type \
        >::value                                            \
    >                                                       \
> : std::true_type {}

CREATE_MEMBER_ENUM_CHECK:

//Check for member enum with given name.
#define CREATE_MEMBER_ENUM_CHECK(enum_name)                 \
                                                            \
template             \
struct has_member_enum_##enum_name : std::false_type {};    \
                                                            \
template                                        \
struct has_member_enum_##enum_name<                         \
    T                                                       \
    , std::integral_constant<                               \
        bool                                                \
        , std::is_enum<                                     \
            typename got_type::type  \
        >::value                                            \
    >                                                       \
> : std::true_type {}

CREATE_MEMBER_FUNC_CHECK:

//Check for function with given name, any signature.
#define CREATE_MEMBER_FUNC_CHECK(func)          \
template                            \
struct has_member_func_##func {                 \
    static const bool value                     \
        = has_member_##func::value           \
        && !has_member_var_##func::value     \
        && !has_member_class_##func::value   \
        && !has_member_union_##func::value   \
        && !has_member_enum_##func::value    \
    ;                                           \
}

CREATE_MEMBER_CHECKS:

//Create all the checks for one member.  Does NOT include func sig checks.
#define CREATE_MEMBER_CHECKS(member)    \
CREATE_MEMBER_CHECK(member);            \
CREATE_MEMBER_VAR_CHECK(member);        \
CREATE_MEMBER_CLASS_CHECK(member);      \
CREATE_MEMBER_UNION_CHECK(member);      \
CREATE_MEMBER_ENUM_CHECK(member);       \
CREATE_MEMBER_FUNC_CHECK(member)

如果您知道您期望的成员函数的名称,这应该足够了.(在这种情况下,如果没有成员函数,函数bla无法实例化(编写一个无论如何都很难,因为缺少函数部分特化.你可能需要使用类模板)另外,启用结构(这个类似于enable_if)也可以模仿你希望它作为成员的函数类型.

template  struct enable { typedef T type; };
template  typename enable::type bla (T&);
struct A { void i(); };
struct B { int i(); };
int main()
{
  A a;
  B b;
  bla(b);
  bla(a);
}

我自己也遇到了同样的问题，并在这里发现了所提出的解决方案非常有趣...但是对解决方案的要求是：

同时检测继承的函数；

与非C ++ 11就绪的编译器兼容（因此没有decltype）

发现了另一个线程提出像这样的基础上，BOOST讨论。这是建议的解决方案的概括，遵循boost :: has_ *类的模型，作为traits类的两个宏声明。

#include 
#include 

/// Has constant function
/** \param func_ret_type Function return type
    \param func_name Function name
    \param ... Variadic arguments are for the function parameters
*/
#define DECLARE_TRAITS_HAS_FUNC_C(func_ret_type, func_name, ...) \
    __DECLARE_TRAITS_HAS_FUNC(1, func_ret_type, func_name, ##__VA_ARGS__)

/// Has non-const function
/** \param func_ret_type Function return type
    \param func_name Function name
    \param ... Variadic arguments are for the function parameters
*/
#define DECLARE_TRAITS_HAS_FUNC(func_ret_type, func_name, ...) \
    __DECLARE_TRAITS_HAS_FUNC(0, func_ret_type, func_name, ##__VA_ARGS__)

// Traits content
#define __DECLARE_TRAITS_HAS_FUNC(func_const, func_ret_type, func_name, ...)  \
    template                                                                  \
    <   typename Type,                                                        \
        bool is_class = boost::is_class::value                          \
    >                                                                         \
    class has_func_ ## func_name;                                             \
    template                                                   \
    class has_func_ ## func_name                                  \
    {public:                                                                  \
        BOOST_STATIC_CONSTANT( bool, value = false );                         \
        typedef boost::false_type type;                                       \
    };                                                                        \
    template                                                   \
    class has_func_ ## func_name                                   \
    {   struct yes { char _foo; };                                            \
        struct no { yes _foo[2]; };                                           \
        struct Fallback                                                       \
        {   func_ret_type func_name( __VA_ARGS__ )                            \
                UTILITY_OPTIONAL(func_const,const) {}                         \
        };                                                                    \
        struct Derived : public Type, public Fallback {};                     \
        template   class Helper{};                           \
        template                                                  \
        static no deduce(U*, Helper                                           \
            <   func_ret_type (Fallback::*)( __VA_ARGS__ )                    \
                    UTILITY_OPTIONAL(func_const,const),                       \
                &U::func_name                                                 \
            >* = 0                                                            \
        );                                                                    \
        static yes deduce(...);                                               \
    public:                                                                   \
        BOOST_STATIC_CONSTANT(                                                \
            bool,                                                             \
            value = sizeof(yes)                                               \
                == sizeof( deduce( static_cast(0) ) )               \
        );                                                                    \
        typedef ::boost::integral_constant type;                  \
        BOOST_STATIC_CONSTANT(bool, is_const = func_const);                   \
        typedef func_ret_type return_type;                                    \
        typedef ::boost::mpl::vector< __VA_ARGS__ > args_type;                \
    }

// Utility functions
#define UTILITY_OPTIONAL(condition, ...) UTILITY_INDIRECT_CALL( __UTILITY_OPTIONAL_ ## condition , ##__VA_ARGS__ )
#define UTILITY_INDIRECT_CALL(macro, ...) macro ( __VA_ARGS__ )
#define __UTILITY_OPTIONAL_0(...)
#define __UTILITY_OPTIONAL_1(...) __VA_ARGS__

这些宏使用以下原型扩展为traits类：

template
class has_func_[func_name]
{
public:
    /// Function definition result value
    /** Tells if the tested function is defined for type T or not.
    */
    static const bool value = true | false;

    /// Function definition result type
    /** Type representing the value attribute usable in
        http://www.boost.org/doc/libs/1_53_0/libs/utility/enable_if.html
    */
    typedef boost::integral_constant type;

    /// Tested function constness indicator
    /** Indicates if the tested function is const or not.
        This value is not deduced, it is forced depending
        on the user call to one of the traits generators.
    */
    static const bool is_const = true | false;

    /// Tested function return type
    /** Indicates the return type of the tested function.
        This value is not deduced, it is forced depending
        on the user's arguments to the traits generators.
    */
    typedef func_ret_type return_type;

    /// Tested function arguments types
    /** Indicates the arguments types of the tested function.
        This value is not deduced, it is forced depending
        on the user's arguments to the traits generators.
    */
    typedef ::boost::mpl::vector< __VA_ARGS__ > args_type;
};

那么，一个典型的用法是什么呢？

// We enclose the traits class into
// a namespace to avoid collisions
namespace ns_0 {
    // Next line will declare the traits class
    // to detect the member function void foo(int,int) const
    DECLARE_TRAITS_HAS_FUNC_C(void, foo, int, int);
}

// we can use BOOST to help in using the traits
#include 

// Here is a function that is active for types
// declaring the good member function
template inline
typename boost::enable_if< ns_0::has_func_foo >::type
foo_bar(const T &_this_, int a=0, int b=1)
{   _this_.foo(a,b);
}

// Here is a function that is active for types
// NOT declaring the good member function
template inline
typename boost::disable_if< ns_0::has_func_foo >::type
foo_bar(const T &_this_, int a=0, int b=1)
{   default_foo(_this_,a,b);
}

// Let us declare test types
struct empty
{
};
struct direct_foo
{
    void foo(int,int);
};
struct direct_const_foo
{
    void foo(int,int) const;
};
struct inherited_const_foo :
    public direct_const_foo
{
};

// Now anywhere in your code you can seamlessly use
// the foo_bar function on any object:
void test()
{
    int a;
    foo_bar(a); // calls default_foo

    empty b;
    foo_bar(b); // calls default_foo

    direct_foo c;
    foo_bar(c); // calls default_foo (member function is not const)

    direct_const_foo d;
    foo_bar(d); // calls d.foo (member function is const)

    inherited_const_foo e;
    foo_bar(e); // calls e.foo (inherited member function)
}

这是对Mike Kinghan答案的简单理解。这将检测继承的方法。它还将检查确切的签名（与jrok的方法允许参数转换不同）。

template 
class HasGreetMethod
{
    template 
    static std::true_type testSignature(void (T::*)(const char*) const);

    template 
    static decltype(testSignature(&T::greet)) test(std::nullptr_t);

    template 
    static std::false_type test(...);

public:
    using type = decltype(test(nullptr));
    static const bool value = type::value;
};

struct A { void greet(const char* name) const; };
struct Derived : A { };
static_assert(HasGreetMethod::value, "");

可运行的例子

为此，我们需要使用：

根据方法是否可用，具有不同返回类型的函数模板重载

为了与type_traits标头中的元条件保持一致，我们将希望从过载中返回a true_type或false_type

声明要使用的true_type期望过载int和false_type期望可变参数的过载：“过载分辨率中省略号转换的最低优先级”

在定义true_type函数的模板规范时，我们将使用它declval并decltype允许我们独立于方法之间的返回类型差异或重载而检测函数

您可以在此处看到一个实时示例。但我也会在下面进行解释：

我想检查是否存在一个名为的函数，该函数test采用可从转换的类型int，那么我需要声明以下两个函数：

template ().test(declval))> static true_type hasTest(int);
template  static false_type hasTest(...);

decltype(hasTest(0))::value是true（因为int可以转换为double int b::test(double)，与返回类型无关）

#define FOO(FUNCTION, DEFINE) template ().FUNCTION)> static true_type __ ## DEFINE(int); \
                              template  static false_type __ ## DEFINE(...); \
                              template  using DEFINE = decltype(__ ## DEFINE(0));

namespace details {
    FOO(test(declval()), test_int)
    FOO(test(), test_void)
}