如何创建接受具有不同签名的函数指针的 C++ 类？

Question

I am relatively new to C++ and I am working on a personal project for practicing where I need to create a class that can take function pointers with different signatures.

The idea is that each instance of the class will store a pointer to a specific function and can call that function whenever I want.

To give a better idea of what I want, let me explain with a little bit more detail what I am trying to do. The project I am working on is a very basic console game and the object I am trying to create is an object that would store details on each location the player can access in the game.

(DISCLAIMER: I know that most of what I describe later is probably an overkill for a basic console game. I can easily make the whole game in a couple of files using just simple functions and I know how to do that. But the idea here is that I wanted to practice more advanced C++ techniques without having to figure out a complex project. So, since I know how to make a basic console game, I thought it would be a good idea to try and figure out how to achieve the same result but with more advanced techniques)

One of the details that I think should be stored is what happens in each location, basically the text that is output to the screen describing what happens and prompting the user to take action.

Since this would be different for each location, I can't just declare and implement a function in the class.

One way of solving this issue is to create a base class with a virtual function and then implement this function in a series of derived classes, each defining a new location.

The problem I have with this approach is that it makes each location a class that can be inherited further and instanced, which I don't need as I will only have 1 instance of each location.

I can of course just create 1 instance of the class, but I wanted to see if there is a way to avoid having to create separate classes for each location.

This why I started thinking of function pointers.

Now, I know I can declare a function pointer and initialise it in a class like that:

class Test
{
    public:
        Test(void (*p)())
            : print{p}
        {}
    private:
        void (*print)();
};

That works fine as long as the function returns void and accepts no arguments.

So, I thought maybe I can do that with a template:

template <typename Function>
class Test
{
    public:
        Test(Function *p)
            : print{p}
        {}
        Function *print;
};

This actually works well. I can now have a class that accepts different functions with different return types.

I can create instances of the class in the following way:

void print();

Test<void ()> a {print};

However, I have one problem with this approach. Because it is a class template, I can't have a pointer that I want to use to point to instances of Test class regardless of the function that is passed to them.

For instance, if I declare the following pointer:

Test<void ()> *b = &a;

There is no way to re-assign that pointer to another instance of Test class unless the function pointer passed to it also returns void and accepts no arguments. Otherwise, I have to create a new pointer.

Is there a way to avoid that? Is there a better way of achieving what I am looking for than using function pointers?

Thank you very much and sorry for the long message.

Answer 1

There is no way to re-assign that pointer to another instance of Test class unless the function pointer passed to it also returns void and accepts no arguments.

And how would you expect that to work? Each Test has a different signature for its print method. In the example below, if you assigned action2 to action1 , then how would it know what to pass to the print function?

void fun1() {}
void fun2(int) {}

void test() {
  Test<void()> action1= &fun1;
  action1.print();
  Test<void(int)> action2= &fun2;
  action2.print(42);
}

What you want is really simple, thanks to improvements in C++11: std::function<void()> .

Whenever you need to pass some arguments to the function, you'd use a lambda, potentially with captures:

#include <functional>

void fun1() {}
void fun2(int) {}

using Action = std::function<void()>;

int main() {
  class MyObject { public: void doSomething() {} } obj;

  Action action1;
  action1 = fun1;
  action1 = []{ fun2(42); };
  action1 = [&obj]{ obj.doSomething(); }; // obj captured by reference
}

So that's pretty much what you should do.

Now of course you may ask "hey, but what if I wanted to implement something like std::function myself"? It's not a trivial task, if you want to get full functionality of std::function , including small object optimization (ie std::function usually doesn't allocate unless the functor it wraps is "big").

I wanted to see what can I do if I had a reason to have the each game location using a function that have different return types.

You chose to use a common abstraction, ie some class (like Action ) that you can always call the same way, and get to do various things. So, what would you like the following code to do?

Action someAction;
int result = someAction();
std::string result = someAction();

Now suppose that eg someAction has captured a void() function. What should the code that assigns the "result" to an integer or a string do? And how would you protect from mistakes, eg if you really wanted someAction() to return an int, but you accidentally used one that returns nothing?

Remember that the compiler has to generate code for all of the sites where you call someAction , so it needs to know what to do ahead of time, even if you may otherwise ensure that no "incorrect" calls are made.

You could implement a custom Action class on top of std::function that could support std::optional<ResultType> instead of ResultType . That way, if the actual result of the functor wrapped in Action was convertible to that ResultType , you'd get a non-null optional, otherwise the optional would be null. And the list of supported result types would need to be pre-determined, ie the compiler wouldn't be able to dynamically add them, but adding a new type should amount to passing an additional type as a template argument, so it'd be easy to support quite many types.