C++ Function Pointers to an Object - c++

Question

I'm not sure if this is possible in C++. I know you can pass a pointer to a function or static member function as a parameter. I want a function pointer for a specific object, so that when the function is executed, it is done on the object.
class MyClass
{
public:
MyClass(int id){mId = id;}
void execute(){cout<<mId<<endl;}
private:
int mId;
};
MyClass obj1(1);
MyClass obj2(2);
typedef (Executor)();
Executor ex1 = &obj1::execute();
Executor ex2 = &obj2::execute();
So when ex1 is executed, "1" should be printed and if ex2 is execute, "2" is printed. Is this possible?

Answer 1

The facility that handles this is the function template bind:
auto ex1 = std::bind(&MyClass::execute, obj1);
You can store a bind in a function object:
std::function<void()> ex1 = std::bind(&MyClass::execute, obj1);
Note that by default bind will store obj by value; you can store a reference with ref:
std::function<void()> ex1 = std::bind(&MyClass::execute, std::ref(obj1));
A related facility is mem_fn, which wraps a member function pointer:
void (MyClass::*ex1)() = &MyClass::execute; // raw member function pointer
ex1(obj1);
auto ex1 = std::mem_fn(&MyClass::execute); // mem_fn wrapper
ex1(obj)
However, because mem_fn doesn't bind an instance, you have to supply the instance each time you call it.
In order to avoid writing the class name when binding a member function, you can use a macro:
#define BIND_MEM_FN(o,m) \
std::bind(&std::remove_reference<decltype(o)>::type::m, (o))
A macro is necessary because you can only form a member function pointer from its type and name, and you cannot pass a name (an unqualified-id) to a function.

Answer 2

It's possible, but not the way you describe it.
You can do it the way proposed by the above comments but more elegant and C++ way would be to use functors.
Functor is basically an object which has operator () overloaded.
In your case it can be something like this:
class MyClass
{
public:
MyClass(int id){mId = id;}
void operator()(){cout<<mId<<endl;}
private:
int mId;
};
MyClass obj1(1);
MyClass obj2(2);
obj1();
obj2();
This way your object actually mimics function behavior.
Here you can read more: http://en.wikipedia.org/wiki/Function_object#In_C_and_C.2B.2B

Answer 3

Member function pointers:
typedef void (MyClass::*Executor)();
Executor ex1 = &MyClass::execute;
Executor ex2 = &MyClass::execute;
obj1.*ex1();
obj2.*ex2();
EDIT: Corrected the code as mentioned in the comments.
I made a mistake because I rarely use (member) function pointers indeed. But not because I use std::bind, but because I use polymorphism :)
Actually I don't remember the last time I used a (member) function pointer except in interfacing with OS APIs. Member function pointers are better than non-member function pointers, and std::bind/std::function might be better than member function pointers, but polymorphism is better than all of the above.