syntax to pass a member function pointer to another class?

hey,

i'm having trouble working out what the syntax is when you want to pass a member function of a class (from a another member function of that class) to another function (which is a member of another class)...

like this:

Code:

---


typedef void(*FnToCallback)(void);

class B
{
public:
void Register(FnToCallback passedInFnToCallback);
void FnThatCallsBackLater();

private:
FnToCallback storedFnToCallback;
};


class A
{
public:
A(B classToRegisterTo);
void CallbackFunction();
};

B instanceOfB;
A instanceOfA(instanceOfB);

A::A(B classToRegisterTo)
{
            classToRegisterTo.Register(CallbackFunction);
}

void A::CallbackFunction()
{
//does something useful
}


void B::Register(FnToCallback passedInFnToCallback)
{
 storedFnToCallback = passedInFnToCallback;
}

void B::FnThatCallsBackLater()
{
storedFnToCallback()
}

int main()
{
//lots of code
instanceOfB.FnThatCallsBackLater();
//more code
}

---

i think that makes sense :eek:

anyway, as it stands, i get an error like this:
cannot convert parameter 1 from 'void (void)' to 'void (__cdecl *)(void)'

i think the problem is that i am trying to pass a pointer to a member function, because if i create a test global function and try to pass that, it works.

thanks in advance to anyone who can decipher all that and help :)

a large cup of coffee has kinda lifted the haze, and its occured to me its nonsense tryng to pass a member function pointer, you need to pass an object pointer, and then call that objects callback method.

so i tried this:

Code:

---


void B::Register(A* objectToCallBack)
{
//stores the parameter
}

void B::FnThatCallsBackLater()
{
storedObjectPointer->Callback();
}

A::A(B* classToRegisterTo)
{
B->Register(this);
}

---

when that code executes however, i get an access violation. although the debugger shows the stored object address and actual object address are the same... which leaves me confused :confused:

you can't make:
void (*callback)(void);
point to:
void A::member_func(void);
you need to use:

Code:

---

void (A::*callback)(void);
callback = A::member_func;

---

more info here:
http://www.vmlinux.org/jakov/communi...com/15837.html

This is where functors come in handy:

Code:

---

struct functor_type
{
 virtual void operator ()(void) {};
};


template <class type>
 struct functor : functor_type
{
  functor()
 {
  self = 0;
  function = 0;
 }
  functor(type * _this, void (type::*some_function)(void))
 {
  make(_this, some_function);
 }
  functor & make(type * _this, void (type::*some_function)(void))
 {
  self = _this;
  function = some_function;
  return *this;
 }
  void operator ()(void)
 {
  (*self.*function)(); // can't use self->function()!
 }
 type * self;
 void (type::*function)(void);
};

---

Notice that the above just covers functions that take no parameters and return nothing. In other words, for every possible function signature you need, you have to code a corresponding functor method. That's one drawback with functors.


Anyway, now you just plug this into the classes themselves. Notice that class 'b' doesn't need to know what type of class gave it a functor, but class 'a' does have to parameterize it's template:

Code:

---

struct b
{
  void Register(functor_type & passedInFnToCallback)
 {
  callback = passedInFnToCallback;
 }
  void FnThatCallsBackLater()
 {
  callback();
 }
 b()
  :callback(dummy)
 {

 }
 functor_type & callback, dummy;
};



 struct a
{
  a(b & B)
 {
  callback.make(this, &a::Callback);

  B.Register(callback);
 }
  void Callback()
 {
  cout << "Hello from 'a'" << endl;
 }
 functor<a> callback;
};

---

Example:

Code:

---

int main()
{
 b b;
 a a(b);
 b.callback();
 return cin.get();
}

---

Hope that helps.

thank you for your help :)