Function Callback, passing different class members

Hi,

I want to define a callback handler that can take different implementations in the class hierarchy.

Here is the way in which i tried to do , but get a compilation error

Code:

#include <iostream>
using namespace std;

class A
{
        public:
                void fun(int){}
};

class B: virtual  public A
{
        public:
                void func(int){}
};

typedef void(A::*TFunPointer)(int);


int main()
{
        A a;
        B b;
        A::TFunPointer t = &A::fun;
        A::TFunPointer t1 = &B::func;
}

I got the Following error in compilation with g++
------klip-------------------
funPointer.cxx: In function `int main()':
funPointer.cxx:24: error: cannot convert `void (B::*)(int)' to `void (A::*)(int)' in initialization
------klap-------------------

Can someone explain why this is not working? Is there any workaround ?

Small change in above code

Code:

#include <iostream>
using namespace std;

class A
{
        public:
                void fun(int){}
};

class B: virtual  public A
{
        public:
                void func(int){}
};

typedef void(A::*TFunPointer)(int);


int main()
{
        A a;
        B b;
        TFunPointer t = &A::fun;
        TFunPointer t1 = &B::func;
}

There are two ways to accomplish what you want. Both rely on polymorphism.
Common code:

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.