szablonu parametr - wskaźnik z funkcji o zmiennej liczbie argumentów argumentów

Question

wiem, że mogę to zrobić:

template<typename T, typename Ret, typename A1, typename A2, Ret(T::*F)(A1, A2)> 
class C{} 

Ale jak widać to A1 i A2 są nieco brzydki. W rzeczywistości nie znam liczby argumentów. Brzmi jak praca dla szablonów variadycznych. Niestety nie mogę tego zrobić:

// doesn't work - parameter pack must appear at the end of the template parameter list 
template<typename T, typename Ret, typename... Args, Ret(T::*F)(Args...)> 
class C{} 

Nor to:

szablon klasy C;

// doesn't work - wrong syntax 
template<typename T, typename F, typename Ret, typename... Args> 
class Delegate2<Ret(T::*F)(Args...)>{} 

Czy chcę za dużo?

Answer 1

Można wykonać następujące czynności:

template<typename T, T> struct C; 

template<typename T, typename R, typename ...Args, R (T::*F)(Args...)> 
struct C<R (T::*)(Args...), F> { 

    R operator()(T &obj, Args &&... args) { 
    return (obj.*F)(std::forward<Args>(args)...); 
    } 

}; 

a potem w swoim programie:

struct A { 
    int foo(int i) { return i; } 
}; 

int main() { 
    C<int(A::*)(int), &A::foo> c; 
    A a; 
    std::cout << c(a, 42) << std::endl; 
} 

Live Demo

Answer 2

template<class T>struct tag{using type=T;}; 
template<class Tag>using type=typename Tag::type; 

template<class T, class Sig> 
struct member_function_pointer; 
template<class T, class Sig> 
using member_function_pointer_t=type<member_function_pointer<T,Sig>>; 

template<class T, class R, class...Args> 
struct member_function_pointer<T, R(Args...)>: 
    tag<R(T::*)(Args...)> 
{}; 

następnie

template<class T, class Sig, member_function_pointer_t<T,Sig> mf> 
class C{}; 

powinien załatwić sprawę. Jeśli potrzebujesz dostępu do Args..., możesz specjalizować się.

template<class T, class Sig, member_function_pointer_t<T,Sig> mf> 
class C; 
template<class T, class R, class...Args, member_function_pointer_t<T,R(Args...)> mf> 
class C<T, R(Args...), mf> { 
}; 

w ten sposób.