Проверьте, имеет ли класс функцию-член с заданной сигнатурой

c++ c++11 templates sfinae

59911 просмотра

14 ответа

Я прошу шаблонный трюк, чтобы определить, имеет ли класс конкретную функцию-член с заданной сигнатурой.

Эта проблема аналогична той, что приведена здесь http://www.gotw.ca/gotw/071.htm, но не та же: в пункте книги Саттера он ответил на вопрос, что класс C ДОЛЖЕН ПРЕДОСТАВЛЯТЬ функцию-член с конкретная подпись, иначе программа не скомпилируется. В моей задаче мне нужно что-то делать, если у класса есть эта функция, иначе делать «что-то еще».

С аналогичной проблемой столкнулся boost :: serialization, но мне не нравится принятое ими решение: шаблонная функция, которая по умолчанию вызывает свободную функцию (которую вы должны определить) с определенной сигнатурой, если вы не определите конкретную функцию-член ( в их случае "serialize", который принимает 2 параметра данного типа) с определенной сигнатурой, иначе произойдет ошибка компиляции. То есть реализовать как навязчивую, так и не навязчивую сериализацию.

Мне не нравится это решение по двум причинам:

  1. Чтобы не быть навязчивым, вы должны переопределить глобальную функцию «сериализации», которая находится в пространстве имен boost :: serialization, поэтому у вас есть В НАШЕМ КЛИЕНТЕ КОДЕ, чтобы открыть повышение пространства имен и сериализацию пространства имен!
  2. Стек для устранения этого беспорядка состоял из 10-12 вызовов функций.

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

Можете ли вы дать мне подсказку, чтобы решить эту загадку?

Автор: ugasoft Источник Размещён: 17.05.2019 02:34

Ответы (14)


85 плюса

Решение

Я не уверен, правильно ли я вас понимаю, но вы можете использовать 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>());
}
Автор: yrp Размещён: 17.09.2008 09:27

111 плюса

Вот возможная реализация, основанная на возможностях C ++ 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
Автор: jrok Размещён: 29.05.2013 09:33

35 плюса

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

#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>это не обеспечит int & T::operator*() const.

Если вы еще не мудры в этом вопросе, то рассмотрение определения std::shared_ptr<T>в заголовке <memory>позволит пролить свет. В этой реализации std::shared_ptr<T>наследуется от базового класса, от которого он наследуется operator*() const. Таким образом, создание экземпляра шаблона SFINAE<U, &U::operator*>, представляющего собой «поиск» оператора for U = std::shared_ptr<T>, не произойдет, поскольку само по себе оно не std::shared_ptr<T>имеет никакого значения, operator*()а создание экземпляра шаблона не «делает наследование».

Эта загвоздка не влияет на хорошо известный подход SFINAE, использующий «трюк sizeof ()», для определения только наличия Tкакой-либо функции-члена mf(см., Например, этот ответ и комментарии). Но установление того, что T::mfсуществует, часто (обычно?) Недостаточно хорошо: вам также может потребоваться установить, что оно имеет желаемую подпись. Вот где проиллюстрирована техника. Указанный вариант требуемой подписи вписан в параметр типа шаблона, который должен быть выполнен &T::mfдля успешного прохождения зонда SFINAE. Но этот метод создания экземпляра шаблона дает неправильный ответ, когда T::mfнаследуется.

Безопасный метод SFINAE для самоанализа во время компиляции T::mfдолжен избегать использования &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;
}

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

Автор: Mike Kinghan Размещён: 22.05.2012 06:23

11 плюса

Этого должно быть достаточно, если вы знаете имя ожидаемой функции-члена. (В этом случае функция 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);
}
Автор: coppro Размещён: 17.09.2008 09:33

10 плюса

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

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

ИЛИ ЖЕ

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

Макросы (Эль Диабло!):

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)
Автор: Brett Rossier Размещён: 31.05.2013 11:30

5 плюса

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

Автор: Valentin Milea Размещён: 21.07.2015 12:42

4 плюса

You can use std::is_member_function_pointer

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

 bool test = std::is_member_function_pointer<decltype(&A::foo)>::value;
Автор: Yochai Timmer Размещён: 07.11.2012 08:58

4 плюса

Came with the same kind of problem myself, and found the proposed solutions in here very interesting... but had the requirement for a solution that:

  1. Detects inherited functions as well;
  2. Is compatible with non C++11 ready compilers (so no decltype)

Found another thread proposing something like this, based on a BOOST discussion. Here is the generalisation of the proposed solution as two macros declaration for traits class, following the model of 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__

These macros expand to a traits class with the following prototype:

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

So what is the typical usage one can do out of this?

// 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)
}
Автор: S. Paris Размещён: 28.03.2013 03:16

4 плюса

To accomplish this we'll need to use:

  1. Function template overloading with differing return types according to whether the method is available
  2. In keeping with the meta-conditionals in the type_traits header, we'll want to return a true_type or false_type from our overloads
  3. Declare the true_type overload expecting an int and the false_type overload expecting Variadic Parameters to exploit: "The lowest priority of the ellipsis conversion in overload resolution"
  4. In defining the template specification for the true_type function we will use declval and decltype allowing us to detect the function independent of return type differences or overloads between methods

You can see a live example of this here. But I'll also explain it below:

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

Автор: Jonathan Mee Размещён: 09.05.2016 01:27

3 плюса

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

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

Автор: Chris Jester-Young Размещён: 17.09.2008 08:44

2 плюса

Хорошо. Вторая попытка Ничего страшного, если тебе тоже не понравится, я ищу больше идей.

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

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

Автор: Chris Jester-Young Размещён: 17.09.2008 09:16

1 плюс

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

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

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

В и являются заменой для корреспондента C ++ 11 классов. Также для понимания шаблонного метапрограммирования они раскрывают саму основу SFINAE-sizeof-трюка.FooFindertrue_typefalse_type

Это TypeSinkшаблонная структура, которая используется позже для погружения интегрального результата sizeofоператора в создание шаблона для формирования типа.

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

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

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

Автор: Kamajii Размещён: 09.07.2017 05:21

0 плюса

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

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

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

http://pastie.org/298994

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

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

штифтик

Автор: Brad Phelan Размещён: 27.10.2008 08:58

0 плюса

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

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

Автор: prehistoricpenguin Размещён: 15.04.2019 03:32
Вопросы из категории :
32x32