There are two ways to accomplish what you want. Both rely on polymorphism.
Common code:
Dynamic polymorphism:
Code:
class Callback
{
public:
virtual void operator () (int arg) = 0;
};
class A: public Callback
{
public:
virtual void operator () (int arg) {}
};
class B: public Callback
{
public:
virtual void operator () (int arg) {}
};
typedef void (Callback::* Callback_t)(int);
void CallbackFunc(Callback_t fnc, Callback& callback)
{
(callback.*fnc)(10);
}
int main()
{
A a;
B b;
CallbackFunc(&Callback::operator (), a);
CallbackFunc(&Callback::operator (), b);
}
Static polymorphism (better approach):
Code:
class A
{
public:
void operator () (int arg){}
};
class B
{
public:
void operator () (int arg){}
};
template<typename T>
void CallbackFunc(T functor)
{
functor(10);
}
int main()
{
CallbackFunc(A());
CallbackFunc(B());
CallbackFunc([](int arg) { }); // Lambda
}
First example is not verified. The second approach is recommended. Again, not tested, however.