Caractère de type pour faire correspondre les signatures des fonctions membres de différentes classes

Question

Quelle est la manière la plus élégante (peut-être C++ 17-way) pour vérifier si les signatures de deux méthodes définies dans deux classes différentes sont exactement les mêmes?

Par exemple:

template< typename ...Ts > 
struct A 
{ 
    void f(Ts...); 
}; 

template< typename ...Ts > 
struct B 
{ 
    void g(Ts...); 
}; 

static_assert(has_same_signatures< decltype(&A<>::f), decltype(&B<>::g) >{}); 
static_assert(!has_same_signatures< decltype(&A<int>::f), decltype(&B<char>::g) >{}); 
//static_assert(has_same_signatures< decltype(&A<void>::f), decltype(&B<>::g) >{}); // don't know is it feasible w/o extra complexity 

Ce serait formidable, si les types de fonctions non-membres de chaque côté seraient autorisés aussi.

Peut-être que le type de résultat devrait aussi être enchevêtré.

La tâche provient du problème commun de la correspondance des signatures signal/emplacement dans le cadre Qt.

Answer 1

Vous pouvez faire quelque chose comme:

// static member functions/free functions are the same 
// if their types are the same 
template <class T, class U> 
struct has_same_signature : std::is_same<T, U> { }; 

// member functions have the same signature if they're two pointers to members 
// with the same pointed-to type 
template <class T, class C1, class C2> 
struct has_same_signature<T C1::*, T C2::*> : std::true_type { }; 

Notez que A<void> est tout simplement mal formé que vous ne pouvez pas avoir un paramètre de type void.