Тип совпадения унаследованных функций-членов

Вот простой класс, который проходит ваши тесты (и не требует дюжины специализаций :)). Это также работает, когда foo перегружен. Подпись, которую вы хотите проверить, также может быть параметром шаблона (это хорошо, правда?).

#include <type_traits>

template <typename T>
struct is_foo {
    template<typename U>
    static auto check(int) ->
    decltype( static_cast< void (U::*)() const >(&U::foo), std::true_type() );
    //                     ^^^^^^^^^^^^^^^^^^^
    //                     the desired signature goes here

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

    static constexpr bool value = decltype(check<T>(0))::value;
};

Живой пример здесь.

ИЗМЕНИТЬ:

У нас есть две перегрузки check. Оба могут принимать целочисленный литерал в качестве параметра, и, поскольку второй имеет многоточие в списке параметров, он никогда не будет лучшим вариантом разрешения перегрузки, когда обе перегрузки жизнеспособны (последовательность-преобразования-эллипса является хуже любой другой последовательности преобразования). Это позволяет нам однозначно инициализировать член value класса признаков позже.

Вторая перегрузка выбирается только тогда, когда первая отбрасывается из набора перегрузок. Это происходит, когда подстановка аргумента шаблона не удалась и не является ошибкой (SFINAE).

Это причудливое выражение слева от оператора запятой внутри decltype делает это возможным. Он может быть плохо сформирован, когда

1. подвыражение &U::foo неправильно сформировано, что может произойти, когда

   • U is not a class type, or
   • U::foo недоступен или
   • нет U::foo

2. результирующий указатель члена не может быть static_cast к целевому типу

Обратите внимание, что поиск &U::foo не завершается ошибкой, если сам U::foo будет неоднозначным. Это гарантируется в определенном контексте, указанном в стандарте C++ в разделе 13.4 (Адрес перегруженной функции, [over.over]). Одним из таких контекстов является явное преобразование типов (в данном случае static_cast).

Выражение также использует тот факт, что T B::* можно преобразовать в T D::*, где D — это класс, производный от B (но не наоборот). Таким образом, нет необходимости выводить тип класса, как в ответе iavr.

Член value затем инициализируется value из true_type или false_type.

Однако есть потенциальная проблема с этим решением. Рассмотреть возможность:

struct X {
    void foo() const;
};

struct Y : X {
    int foo();   // hides X::foo
};

Теперь is_foo<Y>::value даст false, потому что поиск имени для foo остановится, когда встретится Y::foo. Если это нежелательное поведение, рассмотрите возможность передачи класса, в котором вы хотите выполнить поиск, в качестве параметра шаблона is_foo и используйте его вместо &U::foo.

Надеюсь, это поможет.

Ниже приведено рабочее решение вашей проблемы, опубликованное на странице https://ideone.com/mxIVw3 — см. также живой пример.

Эта проблема в некотором смысле является продолжением вывести родительский класс унаследованного метода в C++. В моем ответе я определил черту типа member_class, которая извлекает класс из заданного указателя на тип функции-члена. Ниже мы используем еще несколько признаков для анализа и последующего синтеза такого типа.

Во-первых, member_type извлекает подпись, например. void (C::*)() дает void():

template <typename M> struct member_type_t { };
template <typename M> using  member_type = typename member_type_t <M>::type;

template <typename T, typename C>
struct member_type_t <T C::*> { using type = T;};

Затем member_class извлекает класс, например. void (C::*)() дает C:

template<typename>
struct member_class_t;

template<typename M>
using member_class = typename member_class_t <M>::type;

template<typename R, typename C, typename... A>
struct member_class_t <R(C::*)(A...)> { using type = C; };

template<typename R, typename C, typename... A>
struct member_class_t <R(C::*)(A...) const> { using type = C const; };

// ...other qualifier specializations

Наконец, member_ptr синтезирует указатель на тип функции-члена с учетом класса и подписи, например. C + void() дать void (C::*)():

template <typename C, typename S>
struct member_ptr_t;

template <typename C, typename S>
using member_ptr = typename member_ptr_t <C, S>::type;

template <typename C, typename R, typename ...A>
struct member_ptr_t <C, R(A...)> { using type = R (C::*)(A...); };

template <typename C, typename R, typename ...A>
struct member_ptr_t <C const, R(A...)> { using type = R (C::*)(A...) const; };

// ...other qualifier specializations

Две предыдущие черты нуждаются в большей специализации, чтобы разные квалификаторы были более общими, например. const/volatile или ref-квалификаторы. Есть 12 комбинаций (или 13, включая элементы данных); полная реализация находится здесь< /а>.

template <typename T>
struct is_foo {
private:
    template<
        typename Z,
        typename M = decltype(&Z::foo),
        typename C = typename std::decay<member_class<M>>::type,
        typename S = member_type<M>
    >
    using pattern = member_ptr<C const, void()>;

    template<typename U, U> struct helper{};

    template <typename Z> static auto test(Z z) -> decltype(
        helper<pattern<Z>, &Z::foo>(),
        // All other requirements follow..
        std::true_type()
    );

    template <typename> static auto test(...) -> std::false_type;

public:
    enum { value = std::is_same<decltype(test<T>(std::declval<T>())),std::true_type>::value };
};

M = void (Z::*)() const  ->   Z         +   void()
                         ->   Z const   +   void()
                         ->   void (Z::*)() const   ==   M
                         ->   SUCCESS

M = int (Z::*)() const&  ->   Z const&   +   int()
                         ->   Z const    +   void()
                         ->   void (Z::*)() const   !=   M
                         ->   FAILURE

Если вы просто хотите проверить наличие интерфейса для данного типа T, то есть лучшие способы сделать это. Вот один пример:

template<typename T>
struct has_foo
{
    template<typename U>
    constexpr static auto sfinae(U *obj) -> decltype(obj->foo(), bool()) { return true; }

    constexpr static auto sfinae(...) -> bool { return false; }

    constexpr static bool value = sfinae(static_cast<T*>(0));
};

Тестовый код:

struct A {
    void foo() {}
};

struct B : public A {
    using A::foo;
};

struct C{};

int main() 
{
    std::cout << has_foo<A>::value << std::endl;
    std::cout << has_foo<B>::value << std::endl;
    std::cout << has_foo<C>::value << std::endl;
    std::cout << has_foo<int>::value << std::endl;
    return 0;
}

Вывод (демонстрация):

1
1
0
0

Надеюсь, это поможет.

Я предлагаю использовать decltype для общего определения типа указателей на функции-члены:

helper<decltype(&A::foo), &A::foo> compiles;
helper<decltype(&B::foo), &B::foo> also_compiles;

Это может показаться нарушением DRY, но повторять имя принципиально не хуже, чем указывать тип отдельно от имени.