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

Рабочее решение вашей проблемы, опубликованное на 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 или реф-квалификаторы. Есть 12 комбинаций (или 13, включая элементы данных); полная реализация Вот.

Идея состоит в том, что любые классификаторы передаются member_class от указателя на тип функции-члена до самого класса. затем member_ptr переводит классификаторы из класса обратно в тип указателя. Пока квалификаторы относятся к типу класса, можно свободно манипулировать стандартными чертами, например, добавить или удалить const, lvalue / rvalue ссылки и т. д.

Теперь вот ваш is_foo тестовое задание:

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

Данный тип Zпсевдоним шаблона pattern получает правильный тип M указателя члена с decltype(&Z::foo)извлекает его decay‘класс C и подпись Sи синтезирует новый тип указатель на член-функцию с классом C const и подпись void()т.е. void (C::*)() const, Это именно то, что вам нужно: то же самое с вашим оригинальным жестко закодированным шаблоном, с типом Z заменен на правильный класс C (возможно, базовый класс), как найдено decltype,

Графически:

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

На самом деле, подпись S здесь не было необходимости, поэтому не было member_type, Но я использовал это в процессе, поэтому я включил это здесь для полноты. Это может быть полезно в более общих случаях.

Конечно, все это не будет работать для нескольких перегрузок, потому что decltype не работает в этом случае.

Если вы просто хотите проверить существование интерфейса для данного типа 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 нарушение, но повторение имени принципиально не хуже, чем указание типа отдельно от имени.