Ответ 1

Я не уверен, правильно ли я вас понимаю, но вы можете использовать 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>());
}

Ответ 2

Здесь возможна реализация, основанная на возможностях С++ 11. Он корректно определяет функцию, даже если она унаследована (в отличие от решения в принятом ответе, как говорит Майк Кингхан в его ответ).

Функция, которую этот фрагмент проверяет, называется 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

Ответ 3

Принятый ответ на этот вопрос о членной функции compiletime интроспекция, хотя она по праву популярна, имеет запах, который можно наблюдать в следующей программе:

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

/*  Here we apply the accepted answer 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> не предоставляет 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, используя "Theofofof() Trick", для обнаружения только того, имеет ли T некоторая функция-член mf (см. этот ответ и комментарии). Но что существует T::mf, часто (обычно?) недостаточно хорошо: вы можете также необходимо установить, что он имеет желаемую подпись. Вот где иллюстрированные оценки техники. Указанный вариант желаемой подписи вписан в параметр типа шаблона, который должен быть удовлетворен &T::mf для успешного использования зонда SFINAE. Но этот экземпляр шаблона метод дает неправильный ответ, когда T::mf наследуется.

Безопасный метод SFINAE для интроспекции T::mf для compiletime должен избегать использование &T::mf в аргументе шаблона для создания экземпляра типа, на котором SFINAE зависит от разрешения шаблона функции. Вместо этого, функция шаблона SFINAE разрешение может зависеть только от конкретных утверждений типа, используемых как типы аргументов перегруженной функции зонда SFINAE.

В ответ на вопрос, который соблюдает это ограничение, я буду иллюстрируют обнаружение компиляции E T::operator*() const, для произвольные T и E. Такая же модель будет применяться 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;

Этот вызов может быть разрешен для перегрузки /* SFINAE operator-exists :) */ из test(), или это может привести к перегрузке /* SFINAE game over :( */. Он не может решить перегрузку /* SFINAE operator-has-correct-sig :) */, потому что тот ожидает только один аргумент, и мы проходим два.

Почему мы проходим два? Просто заставить исключить исключение /* SFINAE operator-has-correct-sig :) */. Второй аргумент не имеет другого значения.

Этот вызов test(0,0) будет разрешен только /* SFINAE operator-exists :) */ в случае, если первый аргумент 0 удовлетворяет первому типу параметра этой перегрузки, которая decltype(&A::operator*), с A = T. 0 будет удовлетворять этому типу на всякий случай T::operator* существует.

Предположим, что компилятор сказал "Да" этому. Затем это происходит с /* 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::*)() const, с A = 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;
}

Есть ли новые недостатки в этой идее? Может ли он быть более общим без лишних падающий фол зацепления, который он избегает?

Ответ 4

Этого должно быть достаточно, если вы знаете имя функции-члена, которую вы ожидаете. (В этом случае функция 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);
}

Ответ 5

Вот некоторые фрагменты использования: * Кишки для всего этого дальше вниз

Проверить член 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;

Проверить членство union x:

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

Проверить членство enum 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;

ИЛИ

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)

Ответ 6

Вот более простой ответ Майка Кингхана. Это обнаружит унаследованные методы. Он также проверит точную сигнатуру (в отличие от подхода 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 пример

Ответ 7

Вы можете использовать std :: is_member_function_pointer

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

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

Ответ 8

Пришел к тому же самому вопросу, и нашел предлагаемые решения здесь очень интересными... но имел требование для решения, которое:

• Обнаруживает и унаследованные функции;
• Совместим с компиляторами, не содержащими С++ 11 (так что нет decltype)

Нашел еще один поток, предложив что-то вроде этого, на основе обсуждение BOOST, Вот обобщение предлагаемого решения как двух деклараций макросов для класса признаков, следуя модели boost:: has_ ​​* классов.

#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__

Эти макросы расширяются до класса признаков со следующим прототипом:

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 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 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)
}

Ответ 9

Для этого нам нужно использовать:

1. Перегрузка шаблона функции различными типами возврата в зависимости от того, доступен ли метод
2. В соответствии с мета-условиями в заголовке type_traits, мы хотим вернуть true_type или false_type из наших перегрузок.
3. true_type перегрузку true_type ожидающую int и перегрузку false_type ожидающую использования параметров Variadic: "Самый низкий приоритет преобразования многоточия в разрешении перегрузки"
4. При определении спецификации шаблона для функции true_type мы будем использовать declval и decltype что позволяет нам определять функцию независимо от различий возвращаемых типов или перегрузок между методами.

Вы можете увидеть живой пример этого здесь. Но я также объясню это ниже:

Я хочу проверить существование функции с именем 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))::value имеет decltype(hasTest<a>(0))::value true (обратите внимание, что нет необходимости создавать специальные функции для работы с перегрузкой void a::test(), void a::test(int) принимается)
• decltype(hasTest<b>(0))::value имеет decltype(hasTest<b>(0))::value true (поскольку int может быть преобразовано в double принимается int b::test(double), независимо от типа возвращаемого значения)
• decltype(hasTest<c>(0))::value имеет decltype(hasTest<c>(0))::value false (c не имеет метода с именем test который принимает тип, преобразуемый из int этого это не принимается)

Это решение имеет 2 недостатка:

1. Требуется объявление метода для пары функций
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>::value или details::test_void<a>::value будет details::test_void<a>::value true или false для целей встроенного кода или метапрограммирования.

Ответ 10

Чтобы быть неинтрузивным, вы также можете поместить serialize в пространство имен сериализуемого класса или класс архива, благодаря Koenig LookUp. Подробнее см. Пространства имен для бесплатных переопределений функций.: -)

Открытие любого пространства имен для реализации свободной функции просто неверно. (например, вы не должны открывать пространство имен std для реализации swap для своих собственных типов, но вместо этого следует использовать поиск Koenig.)

Ответ 11

Хорошо. Вторая попытка. Это нормально, если вам это не нравится, я ищу больше идей.

В статье Херба Саттера рассказывается о чертах. Таким образом, у вас может быть класс признаков, у экземпляра по умолчанию есть резервное поведение, а для каждого класса, где существует ваша функция-член, класс признаков специализирован для вызова функции-члена. Я считаю, что в статье Herb упоминается техника для этого, чтобы она не включала много копий и вставки.

Как я уже сказал, возможно, вам не нужна дополнительная работа с классами "tagging", которые реализуют этот элемент. В этом случае я смотрю на третье решение....

Ответ 12

Без поддержки С++ 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;
}

Как он, надеюсь, работает

A, Aa и B являются рассматриваемыми кланами, Aa является специальным, наследующим элемент, который мы ищем.

В FooFinder true_type и false_type являются заменами соответствующих классов С++ 11. Также для понимания мета-программирования шаблонов они раскрывают саму основу трюка SFINAE-sizeof.

TypeSink - это шаблонная структура, которая используется позже, чтобы потопить интегральный результат оператора sizeof в экземпляр шаблона, чтобы сформировать тип.

Функция match - это еще один шаблон типа SFINAE, который остается без общей копии. Поэтому он может быть создан только в том случае, если тип его аргумента соответствует типу, для которого он был специализирован.

Обе функции test вместе с объявлением перечисления окончательно образуют центральный шаблон SFINAE. Существует универсальный метод, использующий многоточие, которое возвращает false_type, а другой - более конкретные аргументы.

Чтобы создать экземпляр функции test с аргументом шаблона T, необходимо создать экземпляр match, так как для его экземпляра требуется экземпляр аргумента TypeSink. Предостережение заключается в том, что &U::foo, будучи обернутым в аргумент функции, не упоминается в специализированной аргументации шаблона, поэтому унаследованный поиск элементов все еще имеет место.

Ответ 13

Я считаю, что ответ, который вы ищете, находится здесь.

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

и немного более заполненный пример здесь

http://pastie.org/298994

Я использую эту технику для обнаружения присутствия поддерживающего оператора ostream < для рассматриваемого класса и затем генерирует другой бит кода в зависимости.

Я не думал, что это возможно, прежде чем найти связанное решение, но это очень аккуратный трюк. Потратьте время на понимание кода, и это очень важно.

Брэд

Ответ 14

Если вы используете безумие в 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;
}

Хотя детали реализации те же, что и в предыдущем ответе, использовать библиотеку проще.