是否可以编写模板来检查函数的存在？

宏(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)

对于一般问题,这是一个C++ 11解决方案,如果"如果我做了X,它会编译吗？"

template struct type_sink { typedef void type; }; // consumes a type, and makes it `void`
template using type_sink_t = typename type_sink::type;
template struct has_to_string : std::false_type {}; \
template struct has_to_string<
  T,
  type_sink_t< decltype( std::declval().toString() ) >
>: std::true_type {};

性状has_to_string使得has_to_string::value是true当且仅当T有一个方法.toString可以与在此上下文0参数调用.

接下来,我将使用标签调度:

namespace details {
  template
  std::string optionalToString_helper(T* obj, std::true_type /*has_to_string*/) {
    return obj->toString();
  }
  template
  std::string optionalToString_helper(T* obj, std::false_type /*has_to_string*/) {
    return "toString not defined";
  }
}
template
std::string optionalToString(T* obj) {
  return details::optionalToString_helper( obj, has_to_string{} );
}

这比复杂的SFINAE表达更容易维护.

如果你发现自己做了很多,你可以用宏写这些特征,但它们相对简单(每行几行),所以可能不值得:

#define MAKE_CODE_TRAIT( TRAIT_NAME, ... ) \
template struct TRAIT_NAME : std::false_type {}; \
template struct TRAIT_NAME< T, type_sink_t< decltype( __VA_ARGS__ ) > >: std::true_type {};

上面做的是创建一个宏MAKE_CODE_TRAIT.你传递了你想要的特征的名称,以及一些可以测试类型的代码T.从而:

MAKE_CODE_TRAIT( has_to_string, std::declval().toString() )

创建上述特征类.

顺便说一句,上述技术是MS称之为"表达SFINAE"的一部分,他们的2013编译器失败了.

请注意,在C++ 1y中,可以使用以下语法:

template
std::string optionalToString(T* obj) {
  return compiled_if< has_to_string >(*obj, [&](auto&& obj) {
    return obj.toString();
  }) *compiled_else ([&]{ 
    return "toString not defined";
  });
}

这是一个滥用大量C++特性的内联编译条件分支.这样做可能是不值得的,因为(代码是内联的)的好处不值得花费(没有人理解它是如何工作的),但是上述解决方案的存在可能是有意义的.

现在这是一个不错的小谜题 - 很棒的问题!

这是Nicola Bonelli解决方案的替代方案,不依赖于非标准typeof操作员.

遗憾的是,它不适用于GCC(MinGW)3.4.5或Digital Mars 8.42n,但它适用于所有版本的MSVC(包括VC6)和Comeau C++.

较长的注释块具有关于它如何工作(或应该工作)的详细信息.正如它所说,我不确定哪种行为符合标准 - 我欢迎对此进行评论.

更新 - 2008年11月7日:

看起来虽然这段代码在语法上是正确的,但MSVC和Comeau C++显示的行为并不符合标准(感谢Leon Timmermans和litb指向我正确的方向).C++ 03标准说明如下:

14.6.2从属名称[temp.dep]

第3段

在类模板的定义或类模板的成员中,如果类模板的基类依赖于模板参数,则在类的定义时,在非限定名称查找期间不会检查基类作用域.模板或成员或在类模板或成员的实例化期间.

因此,看起来当MSVC或Comeau考虑在实例化模板时在调用站点执行名称查找的toString()成员函数时,这是不正确的(即使它实际上是我在这种情况下寻找的行为).TdoToString()

GCC和数字火星的行为看起来是正确的 - 在这两种情况下,非成员toString()函数都绑定到调用.

老鼠 - 我以为我可能找到了一个聪明的解决方案,而是发现了一些编译器错误......

#include 
#include 

struct Hello
{
    std::string toString() {
        return "Hello";
    }
};

struct Generic {};


// the following namespace keeps the toString() method out of
//  most everything - except the other stuff in this
//  compilation unit

namespace {
    std::string toString()
    {
        return "toString not defined";
    }

    template 
    class optionalToStringImpl : public T
    {
    public:
        std::string doToString() {

            // in theory, the name lookup for this call to 
            //  toString() should find the toString() in 
            //  the base class T if one exists, but if one 
            //  doesn't exist in the base class, it'll 
            //  find the free toString() function in 
            //  the private namespace.
            //
            // This theory works for MSVC (all versions
            //  from VC6 to VC9) and Comeau C++, but
            //  does not work with MinGW 3.4.5 or 
            //  Digital Mars 8.42n
            //
            // I'm honestly not sure what the standard says 
            //  is the correct behavior here - it's sort 
            //  of like ADL (Argument Dependent Lookup - 
            //  also known as Koenig Lookup) but without
            //  arguments (except the implied "this" pointer)

            return toString();
        }
    };
}

template 
std::string optionalToString(T & obj)
{
    // ugly, hacky cast...
    optionalToStringImpl* temp = reinterpret_cast*>( &obj);

    return temp->doToString();
}



int
main(int argc, char *argv[])
{
    Hello helloObj;
    Generic genericObj;

    std::cout << optionalToString( helloObj) << std::endl;
    std::cout << optionalToString( genericObj) << std::endl;
    return 0;
}

如果方法碰巧在基类中定义,则litb提供的标准C++解决方案将无法按预期工作.

有关处理此情况的解决方案,请参阅:

俄语:http: //www.rsdn.ru/forum/message/2759773.1.aspx

Roman.Perepelitsa的英文翻译:http://groups.google.com/group/comp.lang.c++.moderated/tree/browse_frm/thread/4f7c7a96f9afbe44/c95a7b4c645e449f?pli=1

这非常聪明.但是,这个解决方案的一个问题是,如果被测试的类型是不能用作基类的类型(例如原始类型),则会产生编译器错误

在Visual Studio中,我注意到如果使用没有参数的方法,则需要在argments周围插入一对额外的redundant()以在sizeof表达式中推导出().

MSVC具有__if_exists和__if_not_exists关键字(Doc).与Nicola的SFINAE类型一起,我可以像OP一样为GCC和MSVC创建一个检查.

更新:来源可以在这里找到

我在另一个线程中写了一个答案(与上面的解决方案不同)也检查继承的成员函数:

SFINAE检查继承的成员函数

以下是该解决方案的一些示例:

例1:

我们正在检查具有以下签名的成员: T::const_iterator begin() const

template struct has_const_begin
{
    typedef char (&Yes)[1];
    typedef char (&No)[2];

    template 
    static Yes test(U const * data, 
                    typename std::enable_ifbegin())
                    >::value>::type * = 0);
    static No test(...);
    static const bool value = sizeof(Yes) == sizeof(has_const_begin::test((typename std::remove_reference::type*)0));
};

请注意,它甚至检查方法的常量,并使用原始类型.(我的意思has_const_begin::value是假,不会导致编译时错误.)

例2

现在我们正在寻找签名: void foo(MyClass&, unsigned)

template struct has_foo
{
    typedef char (&Yes)[1];
    typedef char (&No)[2];

    template
    static Yes test(U * data, MyClass* arg1 = 0,
                    typename std::enable_iffoo(*arg1, 1u))
                    >::value>::type * = 0);
    static No test(...);
    static const bool value = sizeof(Yes) == sizeof(has_foo::test((typename std::remove_reference::type*)0));
};

请注意,MyClass不必是默认构造或满足任何特殊概念.该技术也适用于模板成员.

我急切地等待着这个意见.