🚀 go-pugleaf

Does the C++ standard allow for a generic callback to be specified?

Basically, I'd like to be able to pass an arbitrary object and function of
that object to be called at some later time.  For example:

void DoIt(ANYOBJECT* Object, void (ANYOBJECT::*CallBack)( ...parmlist... ))
{
	[...]
	Object->*CallBack( ...parms... );
	[...]
}


I'd like to be able to call "DoIt" with any type of object and a pointer to
any of that object's member functions that match the 'parmlist'.  As it
stands, any object passed in would have to be in the same class hierarchy
as ANYOBJECT, thus basically requiring a unified class hierachy in order to
do this genericly.

Here is a more complex example that actually stores the object and member
function pointer so it can be called at a later time:

typedef	void (ANYOBJECT::*CallBackFunc)( ...parmlist... );
ANYOBJECT*	MyClass::CallObj;
CallBackFunc	MyClass::CallFunc;

void MyClass::Set(ANYOBJECT* Object, CallBackFunc* Func)
{
	CallObj = Object;
	CallFunc= Func;
}

void MyClass::Call( ...parms... )
{
	CallObj->*Func( ...parms... );
}


Templates do not work well because the type of object to be stored could
be based on the internal state of the program and not know until run-time,
long after the actual instance of "MyClass" has been created.

So...  Is this possible?


                                        Brian
                                 ( bcwhite@bnr.ca )

-------------------------------------------------------------------------------
    In theory, theory and practice are the same.  In practice, they're not.
---
[ comp.std.c++ is moderated.  Submission address: std-c++@ncar.ucar.edu.
  Contact address: std-c++-request@ncar.ucar.edu.  The moderation policy is
  in http://reality.sgi.com/employees/austern_mti/std-c++/policy.html. ]