Ufdjrw

I want to create a generator which for each pointer to function will create a static function to which the pointer can point to:

template <auto &PtrToIsrHandler, auto MemberFunction> struct enable_member_isr_handler

 using TypeOfCFunPtr = std::remove_reference_t<decltype(PtrToIsrHandler)>;
 using TypeOfCFunPointed = std::remove_pointer_t<TypeOfCFunPtr>;
 using RetType = std::invoke_result_t<TypeOfCFunPointed>;
 static RetType isr_handler(/* dunno what to put here */)
 
 return /* call MemberFunction here somehow */;
 

 enable_member_isr_handler()
 
 PtrToIsrHandler = isr_handler;
 

;

In the parameter list of the isr_handler method I tried to put a tuple by using:

template <typename T> struct get_parameters;
template <typename Ret, typename... Args> struct get_parameters<Ret(Args...)>

 using args_t = std::tuple<Args...>;
;

But I get then:

error: invalid conversion from void (*)(get_parameters<void()>)}’ to ‘void (*)()’

How can I make it in such a way that PtrToIsrHandler could be a valid pointer to isr_handler?

As mentioned in my comment, one approach to get the argument list is to use partial specialization and forward the type of the passed in member function. The same approach can be used on free functions as well.

#include <iostream>

template <auto MemberFunction, class MemberFunctionType>
struct handler_impl;

template <auto MemberFunction, class ReturnType, class ClassType, class... Args>
struct handler_impl<MemberFunction, ReturnType(ClassType::*)(Args...)> 
 // here you have access to return-type, class-type and args

 static ReturnType call_on_instance(ClassType& obj, Args... args) 
 return (obj.*MemberFunction)(args...);
 
;

template <auto MemberFunction>
using handler = handler_impl<MemberFunction, decltype(MemberFunction)>;

struct Foo 
 int print(int x) 
 std::cout << x*x << std::endl;
 return x;
 
;

int main() 
 Foo f;
 handler<&Foo::print>::call_on_instance(f, 7);

One thing to keep in mind here is that we are not using perfect forwarding. The easiest approach is to simply make call_on_instance a template function, then we don't really need to care about the arguments and return value, we can let the compiler deduce it.

Another option is to use the approach I showed above and use a static_assert to make sure the argument list passed in is valid, and thus give a better error message when used in the wrong way.