如何制作一个将任意函数指针作为参数的函数？

Question

I am trying to do the following, and I am not even sure if it's possible.

I want a function that takes in an arbitrary function pointer to pass it to a different function (I am aware this is a code smell, good software engineering practices are not what I want to discuss right now).

In other words what I am looking for would look like:

void method1(arbitraty pointer p)
{
    method2(p);
}

I am not sure if there is a way to declare arbitrary function pointers (the return value is guaranteed to be void but the parameters are arbitrary, both in number and type)

Answer 1

Use template and use SFINAE to enable it only if the type deduced is a function pointer type:

template <typename T, std::enable_if_t<std::is_function<T>::value, int> = 0>
void method1(T* p)
{
    // ...
}

Answer 2

This might be considered over-engineering by some, but you could try the following:

Create an enum of each callback that you are interested in:

enum GlfwCallback {
    KeyCallback,
    FramebufferSizeCallback,
    // etc.
};

Then create a type family that associates each of these with the corresponding function pointer type. Do this by creating a template struct and repeatedly specializing it:

template<GflwCallback callback>
struct GlfwCallbackType {};

template<>
struct GlfwCallbackType<KeyCallback> {
    using CallbackType = GLFWkeyfun;
    // or
    using CallbackType = void(*)(GLFWwindow *, int, int, int, int);
};

template<>
struct GlfwCallbackType<FramebufferSizeCallback> {
    using CallbackType =  GLFWframebuffersizefun;
};

// etc.

Then you can write

template<GlfwCallback callback>
void method1(GlfwCallbackType<callback>::CallbackType p) {
    // do something with p
    method2<callback>(p);
};

Also, note that you can add other types and even static functions and data members to your "type family" as needed by your application.

Answer 3

A possibility to do what you want, but in a nice, type-safe fashion, would be the use of functors, ie classes that define an overloading for the operator() .
Since a functor is a class, you could set the arguments as data memebers, and move the implementation/calling of the functions that you want to pass as arbitrary pointers into the operator() method, where you can have access to all the parameters through the this pointer.

Furthermore, you can define a hierarchy of functors, each one with specialized parameters and implementations, so you can modify the signature of method2 like the following:

method2(BaseFunctor* myfunctor) {
   if (myfunctor) 
      (*myfucntor)();
} 

and setup the right type of functor object in the calling context.

Also check out lambdas (c++11), that are basically a shortcut to functors definition.