it-swarm.cn

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

我要求一个模板技巧来检测一个类是否具有给定签名的特定成员函数。

问题类似于这里引用的问题 http://www.gotw.ca/gotw/071.htm 但不一样:在Sutter的书中,他回答了C级必须提供的问题。具有特定签名的成员函数,否则程序将无法编译。在我的问题中,我需要做一些事情,如果一个类有这个功能,否则做“其他”。

Boost :: serialization面临类似的问题,但我不喜欢他们采用的解决方案:模板函数默认调用具有特定签名的自由函数(您必须定义),除非您定义特定的成员函数(在他们的情况下“序列化”,它采用给定类型的2个参数)与特定签名,否则将发生编译错误。那就是实现侵入式和非侵入式序列化。

我不喜欢这个解决方案有两个原因:

  1. 要非侵入式,您必须覆盖boost :: serialization命名空间中的全局“序列化”函数,因此您可以在您的客户端代码中打开命名空间提升和命名空间序列化!
  2. 解决这个混乱的堆栈是10到12个函数调用。

我需要为没有该成员函数的类定义自定义行为,并且我的实体位于不同的名称空间内(我不想覆盖在一个名称空间中定义的全局函数,而我在另一个名称空间中)

你能给我一个解决这个难题的提示吗?

116
ugasoft

我不确定我是否理解正确,但你可以利用SFINAE在编译时检测函数的存在。我的代码示例(测试类是否具有成员函数size_t used_memory()const)。

template<typename T>
struct HasUsedMemoryMethod
{
    template<typename U, size_t (U::*)() const> struct SFINAE {};
    template<typename U> static char Test(SFINAE<U, &U::used_memory>*);
    template<typename U> static int Test(...);
    static const bool Has = sizeof(Test<T>(0)) == sizeof(char);
};

template<typename TMap>
void ReportMemUsage(const TMap& m, std::true_type)
{
        // We may call used_memory() on m here.
}
template<typename TMap>
void ReportMemUsage(const TMap&, std::false_type)
{
}
template<typename TMap>
void ReportMemUsage(const TMap& m)
{
    ReportMemUsage(m, 
        std::integral_constant<bool, HasUsedMemoryMethod<TMap>::Has>());
}
86
yrp

这是一个依赖于C++ 11特性的可能实现。即使它被继承,它也能正确检测到该功能(与接受的答案中的解决方案不同,正如Mike Kinghan在 他的回答中所述 )。

此代码段测试的函数称为serialize

#include <type_traits>

// Primary template with a static assertion
// for a meaningful error message
// if it ever gets instantiated.
// We could leave it undefined if we didn't care.

template<typename, typename T>
struct has_serialize {
    static_assert(
        std::integral_constant<T, false>::value,
        "Second template parameter needs to be of function type.");
};

// specialization that does the checking

template<typename C, typename Ret, typename... Args>
struct has_serialize<C, Ret(Args...)> {
private:
    template<typename T>
    static constexpr auto check(T*)
    -> typename
        std::is_same<
            decltype( std::declval<T>().serialize( std::declval<Args>()... ) ),
            Ret    // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        >::type;  // attempt to call it and see if the return type is correct

    template<typename>
    static constexpr std::false_type check(...);

    typedef decltype(check<C>(0)) type;

public:
    static constexpr bool value = type::value;
};

用法:

struct X {
     int serialize(const std::string&) { return 42; } 
};

struct Y : X {};

std::cout << has_serialize<Y, int(const std::string&)>::value; // will print 1
112
jrok

对于这个编译时成员函数内省问题的接受答案,虽然它很受欢迎,但在以下程序中可以观察到这个问题:

#include <type_traits>
#include <iostream>
#include <memory>

/*  Here we apply the accepted answer's technique to probe for the
    the existence of `E T::operator*() const`
*/
template<typename T, typename E>
struct has_const_reference_op
{
    template<typename U, E (U::*)() const> struct SFINAE {};
    template<typename U> static char Test(SFINAE<U, &U::operator*>*);
    template<typename U> static int Test(...);
    static const bool value = sizeof(Test<T>(0)) == sizeof(char);
};

using namespace std;

/* Here we test the `std::` smart pointer templates, including the
    deprecated `auto_ptr<T>`, to determine in each case whether
    T = (the template instantiated for `int`) provides 
    `int & T::operator*() const` - which all of them in fact do.
*/ 
int main(void)
{
    cout << has_const_reference_op<auto_ptr<int>,int &>::value;
    cout << has_const_reference_op<unique_ptr<int>,int &>::value;
    cout << has_const_reference_op<shared_ptr<int>,int &>::value << endl;
    return 0;
}

使用GCC 4.6.3构建,程序输出110 - 通知我们T = std::shared_ptr<int>执行not提供int & T::operator*() const

如果你还不熟悉这个问题,那么在std::shared_ptr<T>标题中查看<memory>的定义将会有所帮助。在该实现中,std::shared_ptr<T>派生自一个继承operator*() const的基类。因此,构成“查找”SFINAE<U, &U::operator*>的运算符的模板实例化U = std::shared_ptr<T>将不会发生,因为std::shared_ptr<T>本身没有operator*(),模板实例化不会“继承”。

这个障碍不会影响众所周知的SFINAE方法,使用“the sizeof()Trick”,仅用于检测T是否具有某个成员函数mf(参见例如 此答案 和注释)。但确定T::mf存在通常(通常是?)不够好:您可能还需要确定它具有所需的签名。这就是所示技术得分的地方。所需签名的指针变体被刻入模板类型的参数中,该参数必须由&T::mf满足,以使SFINAE探测成功。但是,当继承T::mf时,此模板实例化技术会给出错误的答案。

用于T::mf的编译时内省的安全SFINAE技术必须避免在模板参数中使用&T::mf来实例化SFINAE函数模板分辨率所依赖的类型。相反,SFINAE模板函数解析只能依赖于用作重载SFINAE探测函数的参数类型的完全相关的类型声明。

通过对这个约束遵循的问题的回答,我将说明E T::operator*() const的编译时检测,对于任意的TE。相同的模式将应用mutatis mutandis来探测任何其他成员方法签名。

#include <type_traits>

/*! The template `has_const_reference_op<T,E>` exports a
    boolean constant `value that is true iff `T` provides
    `E T::operator*() const`
*/ 
template< typename T, typename E>
struct has_const_reference_op
{
    /* SFINAE operator-has-correct-sig :) */
    template<typename A>
    static std::true_type test(E (A::*)() const) {
        return std::true_type();
    }

    /* SFINAE operator-exists :) */
    template <typename A> 
    static decltype(test(&A::operator*)) 
    test(decltype(&A::operator*),void *) {
        /* Operator exists. What about sig? */
        typedef decltype(test(&A::operator*)) return_type; 
        return return_type();
    }

    /* SFINAE game over :( */
    template<typename A>
    static std::false_type test(...) {
        return std::false_type(); 
    }

    /* This will be either `std::true_type` or `std::false_type` */
    typedef decltype(test<T>(0,0)) type;

    static const bool value = type::value; /* Which is it? */
};

在此解决方案中,“递归调用”过载的SFINAE探测函数test()。 (当然它实际上根本没有被调用;它只有编译器解析的假设调用的返回类型。)

我们需要探测至少一个,最多两个信息点:

  • T::operator*()是否存在?如果没有,我们就完成了。
  • 鉴于T::operator*()存在,它的签名是E T::operator*() const吗?

我们通过评估对test(0,0)的单个调用的返回类型来获得答案。这是通过以下方式完成的:

    typedef decltype(test<T>(0,0)) type;

此调用可能会解析为test()/* SFINAE operator-exists :) */重载,或者它可能会解析为/* SFINAE game over :( */重载。它无法解析为/* SFINAE operator-has-correct-sig :) */重载,因为只需要一个参数,我们传递两个。

我们为什么要过两个?只需强制解析即可排除/* SFINAE operator-has-correct-sig :) */。第二个论点没有其他意义。

这个对test(0,0)的调用将解析为/* SFINAE operator-exists :) */,以防第一个参数0使用A = T满足该重载的第一个参数类型decltype(&A::operator*)。如果T::operator*存在,0将满足该类型。

让我们假设编译器对此说“是”。然后它与/* SFINAE operator-exists :) */一起运行,它需要确定函数调用的返回类型,在这种情况下是decltype(test(&A::operator*)) - 又一次调用test()的返回类型。

这一次,我们只传递一个参数&A::operator*,我们现在知道它存在,或者我们不会在这里。对test(&A::operator*)的调用可能会解析为/* SFINAE operator-has-correct-sig :) */或再次解析为/* SFINAE game over :( */。该调用将匹配/* SFINAE operator-has-correct-sig :) */,以防&A::operator*满足该重载的单个参数类型,即E (A::*)() constA = T

如果T::operator*具有所需的签名,编译器将在此处说“是”,然后再次必须评估重载的返回类型。现在不再有“递归”:它是std::true_type

如果编译器没有选择/* SFINAE operator-exists :) */用于调用test(0,0)或者没有选择/* SFINAE operator-has-correct-sig :) */用于调用test(&A::operator*),那么在任何一种情况下它都与/* SFINAE game over :( */一起使用,最终的返回类型是std::false_type

这是一个测试程序,显示模板在不同的案例样本中产生预期答案(GCC 4.6.3再次)。

// To test
struct empty{};

// To test 
struct int_ref
{
    int & operator*() const {
        return *_pint;
    }
    int & foo() const {
        return *_pint;
    }
    int * _pint;
};

// To test 
struct sub_int_ref : int_ref{};

// To test 
template<typename E>
struct ee_ref
{
    E & operator*() {
        return *_pe;
    }
    E & foo() const {
        return *_pe;
    }
    E * _pe;
};

// To test 
struct sub_ee_ref : ee_ref<char>{};

using namespace std;

#include <iostream>
#include <memory>
#include <vector>

int main(void)
{
    cout << "Expect Yes" << endl;
    cout << has_const_reference_op<auto_ptr<int>,int &>::value;
    cout << has_const_reference_op<unique_ptr<int>,int &>::value;
    cout << has_const_reference_op<shared_ptr<int>,int &>::value;
    cout << has_const_reference_op<std::vector<int>::iterator,int &>::value;
    cout << has_const_reference_op<std::vector<int>::const_iterator,
            int const &>::value;
    cout << has_const_reference_op<int_ref,int &>::value;
    cout << has_const_reference_op<sub_int_ref,int &>::value  << endl;
    cout << "Expect No" << endl;
    cout << has_const_reference_op<int *,int &>::value;
    cout << has_const_reference_op<unique_ptr<int>,char &>::value;
    cout << has_const_reference_op<unique_ptr<int>,int const &>::value;
    cout << has_const_reference_op<unique_ptr<int>,int>::value;
    cout << has_const_reference_op<unique_ptr<long>,int &>::value;
    cout << has_const_reference_op<int,int>::value;
    cout << has_const_reference_op<std::vector<int>,int &>::value;
    cout << has_const_reference_op<ee_ref<int>,int &>::value;
    cout << has_const_reference_op<sub_ee_ref,int &>::value;
    cout << has_const_reference_op<empty,int &>::value  << endl;
    return 0;
}

这个想法有新的缺陷吗?它可以变得更通用而不会再次避免它避免的障碍吗?

35
Mike Kinghan

以下是一些使用片段:*所有这些的胆量更远

检查给定类中的成员x。可以是var,func,class,union或enum:

CREATE_MEMBER_CHECK(x);
bool has_x = has_member_x<class_to_check_for_x>::value;

检查成员函数void x()

//Func signature MUST have T as template variable here... simpler this way :\
CREATE_MEMBER_FUNC_SIG_CHECK(x, void (T::*)(), void__x);
bool has_func_sig_void__x = has_member_func_void__x<class_to_check_for_x>::value;

检查成员变量x

CREATE_MEMBER_VAR_CHECK(x);
bool has_var_x = has_member_var_x<class_to_check_for_x>::value;

检查成员类x

CREATE_MEMBER_CLASS_CHECK(x);
bool has_class_x = has_member_class_x<class_to_check_for_x>::value;

检查成员联合x

CREATE_MEMBER_UNION_CHECK(x);
bool has_union_x = has_member_union_x<class_to_check_for_x>::value;

检查成员枚举x

CREATE_MEMBER_ENUM_CHECK(x);
bool has_enum_x = has_member_enum_x<class_to_check_for_x>::value;

检查任何成员函数x,无论签名如何:

CREATE_MEMBER_CHECK(x);
CREATE_MEMBER_VAR_CHECK(x);
CREATE_MEMBER_CLASS_CHECK(x);
CREATE_MEMBER_UNION_CHECK(x);
CREATE_MEMBER_ENUM_CHECK(x);
CREATE_MEMBER_FUNC_CHECK(x);
bool has_any_func_x = has_member_func_x<class_to_check_for_x>::value;

OR

CREATE_MEMBER_CHECKS(x);  //Just stamps out the same macro calls as above.
bool has_any_func_x = has_member_func_x<class_to_check_for_x>::value;

细节和核心:

/*
    - Multiple inheritance forces ambiguity of member names.
    - SFINAE is used to make aliases to member names.
    - Expression SFINAE is used in just one generic has_member that can accept
      any alias we pass it.
*/

//Variadic to force ambiguity of class members.  C++11 and up.
template <typename... Args> struct ambiguate : public Args... {};

//Non-variadic version of the line above.
//template <typename A, typename B> struct ambiguate : public A, public B {};

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

template<typename A>
struct got_type<A> : std::true_type {
    typedef A type;
};

template<typename T, T>
struct sig_check : std::true_type {};

template<typename Alias, typename AmbiguitySeed>
struct has_member {
    template<typename C> static char ((&f(decltype(&C::value))))[1];
    template<typename C> static char ((&f(...)))[2];

    //Make sure the member name is consistently spelled the same.
    static_assert(
        (sizeof(f<AmbiguitySeed>(0)) == 1)
        , "Member name specified in AmbiguitySeed is different from member name specified in Alias, or wrong Alias/AmbiguitySeed has been specified."
    );

    static bool const value = sizeof(f<Alias>(0)) == 2;
};

宏(El Diablo!):

CREATE_MEMBER_CHECK:

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

CREATE_MEMBER_VAR_CHECK:

//Check for member variable with given name.
#define CREATE_MEMBER_VAR_CHECK(var_name)                                   \
                                                                            \
template<typename T, typename = std::true_type>                             \
struct has_member_var_##var_name : std::false_type {};                      \
                                                                            \
template<typename T>                                                        \
struct has_member_var_##var_name<                                           \
    T                                                                       \
    , std::integral_constant<                                               \
        bool                                                                \
        , !std::is_member_function_pointer<decltype(&T::var_name)>::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<typename T, typename = std::true_type>                             \
struct has_member_func_##templ_postfix : std::false_type {};                \
                                                                            \
template<typename T>                                                        \
struct has_member_func_##templ_postfix<                                     \
    T, std::integral_constant<                                              \
        bool                                                                \
        , sig_check<func_sig, &T::func_name>::value                         \
    >                                                                       \
> : std::true_type {}

CREATE_MEMBER_CLASS_CHECK:

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

CREATE_MEMBER_UNION_CHECK:

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

CREATE_MEMBER_ENUM_CHECK:

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

CREATE_MEMBER_FUNC_CHECK:

//Check for function with given name, any signature.
#define CREATE_MEMBER_FUNC_CHECK(func)          \
template<typename T>                            \
struct has_member_func_##func {                 \
    static const bool value                     \
        = has_member_##func<T>::value           \
        && !has_member_var_##func<T>::value     \
        && !has_member_class_##func<T>::value   \
        && !has_member_union_##func<T>::value   \
        && !has_member_enum_##func<T>::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)
12
Brett Rossier

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

template <typename T, int (T::*) ()> struct enable { typedef T type; };
template <typename T> typename enable<T, &T::i>::type bla (T&);
struct A { void i(); };
struct B { int i(); };
int main()
{
  A a;
  B b;
  bla(b);
  bla(a);
}
11
coppro

以下简单介绍了Mike Kinghan的回答。这将检测继承的方法。它还将检查 exact signature(与jrok的允许参数转换的方法不同)。

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

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

    template <class T>
    static std::false_type test(...);

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

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

Runnable 示例

5
Valentin Milea

你可以使用std :: is_member_function_pointer

class A {
   public:
     void foo() {};
}

 bool test = std::is_member_function_pointer<decltype(&A::foo)>::value;
4
Yochai Timmer

要做到这一点,我们需要使用:

  1. 函数模板重载 根据方法是否可用而具有不同的返回类型
  2. 为了与 type_traits 标头中的元条件保持一致,我们要从过载中返回 true_typefalse_type
  3. 声明true_type重载,期望intfalse_type重载,期望Variadic参数可以利用: “重载决策中Ellipsis转换的最低优先级”
  4. 在定义true_type函数的模板规范时,我们将使用 declvaldecltype 允许我们检测函数,而不依赖于返回类型差异或方法之间的重载

你可以看到这个 here 的实例。 但我也会在下面解释一下:

我想检查是否存在一个名为test的函数,该函数采用可从int转换的类型,然后我需要声明这两个函数:

template <typename T, typename S = decltype(declval<T>().test(declval<int>))> static true_type hasTest(int);
template <typename T> static false_type hasTest(...);
  • decltype(hasTest<a>(0))::valuetrue(注意,不需要创建特殊功能来处理void a::test()重载,接受void a::test(int)
  • decltype(hasTest<b>(0))::valuetrue(因为int可以转换为doubleint b::test(double)被接受,独立于返回类型)
  • decltype(hasTest<c>(0))::valuefalsec没有名为test的方法,它接受一个可从int转换的类型,因此不接受)

该解决方案有两个缺点:

  1. 需要一对函数的per方法声明
  2. 创建命名空间污染,特别是如果我们想要测试相似的名称,例如我们将一个函数命名为想要测试test()方法?

因此,在细节命名空间中声明这些函数很重要,或者理想情况下,如果它们只用于类,则应该由该类私有声明它们。为此,我编写了一个宏来帮助您抽象出这些信息:

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

你可以这样使用:

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

随后调用details::test_int<a>::valuedetails::test_void<a>::value将产生truefalse,以用于内联代码或元编程。

4
Jonathan Mee

我自己也遇到了同样的问题,并且发现这里提出的解决方案非常有趣......但是需要一个解决方案:

  1. 检测继承的函数;
  2. 与非C++ 11就绪编译器兼容(因此没有decltype)

找到另一个 线程 提出类似这样的东西,基于 BOOST讨论 。以下是提出的解决方案的概括,作为traits类的两个宏声明,遵循 boost :: has_ * classes的模型。

#include <boost/type_traits/is_class.hpp>
#include <boost/mpl/vector.hpp>

/// 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<Type>::value                          \
    >                                                                         \
    class has_func_ ## func_name;                                             \
    template<typename Type>                                                   \
    class has_func_ ## func_name<Type,false>                                  \
    {public:                                                                  \
        BOOST_STATIC_CONSTANT( bool, value = false );                         \
        typedef boost::false_type type;                                       \
    };                                                                        \
    template<typename Type>                                                   \
    class has_func_ ## func_name<Type,true>                                   \
    {   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 <typename T, T t>  class Helper{};                           \
        template <typename U>                                                 \
        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<Derived*>(0) ) )               \
        );                                                                    \
        typedef ::boost::integral_constant<bool,value> 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 T>
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<bool,value> 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 <boost/utility/enable_if.hpp>

// Here is a function that is active for types
// declaring the good member function
template<typename T> inline
typename boost::enable_if< ns_0::has_func_foo<T> >::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<typename T> inline
typename boost::disable_if< ns_0::has_func_foo<T> >::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)
}
4
S. Paris

要进行非侵入式,您还可以将serialize放在要序列化的类的名称空间中,或归档到归档类,这要归功于 Koenig lookup 。请参阅 自由函数覆盖的命名空间 了解更多详细信息。 :-)

打开任何给定的命名空间来实现自由功能是完全错误的。 (例如,您不应该打开命名空间std来为您自己的类型实现swap,但是应该使用Koenig查找。)

3
Chris Jester-Young

好的。第二次尝试。如果你不喜欢这个也没关系,我正在寻找更多的想法。

Herb Sutter的文章讨论了特征。因此,您可以拥有一个traits类,其默认实例化具有回退行为,对于存在成员函数的每个类,traits类专门用于调用成员函数。我相信Herb的文章提到了一种技术来做到这一点,所以它不涉及大量的复制和粘贴。

就像我说的那样,也许你不希望额外的工作涉及“标记”实现该成员的类。在这种情况下,我正在寻找第三种解决方案....

2
Chris Jester-Young

如果没有C++ 11支持(decltype),这可能会起作用:

SSCCE

#include <iostream>
using namespace std;

struct A { void foo(void); };
struct Aa: public A { };
struct B { };

struct retA { int foo(void); };
struct argA { void foo(double); };
struct constA { void foo(void) const; };
struct varA { int foo; };

template<typename T>
struct FooFinder {
    typedef char true_type[1];
    typedef char false_type[2];

    template<int>
    struct TypeSink;

    template<class U>
    static true_type &match(U);

    template<class U>
    static true_type &test(TypeSink<sizeof( matchType<void (U::*)(void)>( &U::foo ) )> *);

    template<class U>
    static false_type &test(...);

    enum { value = (sizeof(test<T>(0, 0)) == sizeof(true_type)) };
};

int main() {
    cout << FooFinder<A>::value << endl;
    cout << FooFinder<Aa>::value << endl;
    cout << FooFinder<B>::value << endl;

    cout << FooFinder<retA>::value << endl;
    cout << FooFinder<argA>::value << endl;
    cout << FooFinder<constA>::value << endl;
    cout << FooFinder<varA>::value << endl;
}

希望如何运作

AAaB是有问题的clases,Aa是继承我们正在寻找的成员的特殊字符。

FooFinder中,true_typefalse_type是对应的C++ 11类的替换。同样为了理解模板元编程,它们揭示了SFINAE-sizeof-trick的基础。

TypeSink是一个模板结构,稍后用于将sizeof运算符的整数结果存入模板实例化以形成类型。

match函数是另一种SFINAE模板,没有通用对应物。因此,只有在其参数的类型与其专用的类型匹配时才能实例化它。

test函数和枚举声明最终形成中央SFINAE模式。有一个泛型的使用省略号返回false_type和一个具有更多特定参数的对应物优先。

为了能够使用test的模板参数实例化T函数,必须实例化match函数,因为需要返回类型来实例化TypeSink参数。需要注意的是,包含在函数参数中的&U::foo not 在模板参数特化中引用,因此仍然会进行继承的成员查找。

1
Kamajii

我相信你要找的答案就在这里。

http://www.martinecker.com/wiki/index.php?title=Detecting_the_Existence_of_Operators_at_Compile-Time

还有一个稍微充实的例子

http://pastie.org/298994

我使用该技术来检测所讨论的类上是否存在支持 ostream运算符<< ,然后生成不同的代码位。

在找到链接解决方案之前我不相信它是可能的,但它是一个非常巧妙的技巧。花时间理解代码,这是非常值得的。

布拉德

0
Brad Phelan

如果你使用facebook愚蠢,他们是开箱即用的宏来帮助你:

#include <folly/Traits.h>
namespace {
  FOLLY_CREATE_HAS_MEMBER_FN_TRAITS(has_test_traits, test);
} // unnamed-namespace

void some_func() {
  cout << "Does class Foo have a member int test() const? "
    << boolalpha << has_test_traits<Foo, int() const>::value;
}

虽然实现细节与前面的答案相同,但使用库更简单。

0
prehistoricpenguin