C++: Function pointer that holds a method from a specific instance - c++

Question

So I'm currently working on an input manager for a C++ game. I was thinking about doing it as a map<char, list<Listener::method>>, so that when I register a button pressed, I call all the methods registered for the specific key.
Problem is, done like that I have to specify the instance which I want to call the method from. Is there a way to hold inside a variable not only the method but the caller instance?
Something like:
class Foo
{
public:
Foo ();
~Foo ();
void DoSomething();
};
Foo fooObject;
void(Foo::*fPtr)(void) = &fooObject::DoSomething;
(*fPtr)();
And that would call fooObject's DoSomething()
Is it possible?
If not, could someone point me to a Event-Listener pattern? Doesnt have to be overcomplicated or threadsafe. Just the basic structure.

Answer 1

The problem with member function pointers is you need an instance of the class to call them on. You can't achieve this with just a pointer because the pointer only points to the function, and not the additional object you need to pass to the function (remember all member functions have an implicit first parameter that takes the class type).
You can use a std::function to have a function object that holds the object to call and the function to call on it. If you have
std::function<void()> func = [&](){ return fooObject.DoSomething(); }; // Bind with a reference. Use this if the object will live as long as the function to save on a copy
std::function<void()> func = [=](){ return fooObject.DoSomething(); }; // Bind with a copy. Use this if the function will outlive the object
then when you call func using func() it will run the body of he lambda which calls DoSomething on fooObject.
You can also use std::bind to bind a member function pointer to a object to call it on but lambdas are generally preferred as the syntax is easy to use.

Answer 2

Is there a way to hold inside a variable not only the method but the caller instance?
Yes, you can bind method and object together.
Since C++11 you have bind utility.
A minimal example from your concept:
struct Foo {
void foo();
};
void bar() {
// your map
std::map<char, std::function<void()>> actions;
// Bind method and object together inside fn
Foo foo;
auto fn = std::bind(&Foo::foo, &foo);
// Insert fn into map
actions.emplace('f', fn);
// call fn from map! Be careful about object lifetime
actions['f']();
}
Godbolt code
Be careful because the "bind object" (fn in my example) will just store a reference to the object foo. Therefore, if you invoke fn after the object foo has been destroyed you will get an undefined behaviour.
In case you want to take care about object lifetime, you can copy it with a lambda function. For example:
auto fn = [foo]() { foo.foo(); }
Or use a custom structure and store a copied object inside.

Answer 3

There is no such thing as a "method from a specific instance".
You can hold a pointer to a member function of a class. Such pointers are not bound to any specific object.
You can use that function pointer on any object of the class.
Given
class Foo
{
public:
Foo ();
~Foo ();
void DoSomething();
};
Any class can hold a pointer to the DoSomething member function (you're calling it a method).
void(Foo::*fPtr)(void) = &Foo::DoSomething;
You would need an object to be able to call the member function. The calling syntax is a bit obtuse but here it is.
Foo foo = <some function call>;
(foo.*fPtr)();

Answer 4

You could use the bind-functionality to get function object having function parameteras already bound to arguments. By that, you can bind the object reference, which is implicitly the first parameter in any non-static member function, to the respective object for which you'd like to have the callback:
class Foo
{
public:
int x;
Foo (int _x) : x(_x) {} ;
void doSomething() { cout << x << endl; }
};
int main() {
Foo fooObject1(1);
Foo fooObject2(2);
std::function<void ()> fx1 = std::bind(&Foo::doSomething,&fooObject1);
std::function<void ()> fx2 = std::bind(&Foo::doSomething,&fooObject2);
std::vector<std::function<void ()>> callbacks;
callbacks.push_back(fx1);
callbacks.push_back(fx2);
for (auto f : callbacks) {
f();
}
}
Output:
1
2