C / C++ / MFC

class R
{
public:
	typedef void (A::*Method)();
	struct MethodCall { Method fn; A obj; };
	MethodCall onClick;

	void Do()
	{
		Method m = onClick.fn;
		A& a = onClick.obj;
      
		((a).*(m))();
	}
};

int main(int argc, char* argv[])
{
	
	A a;

	R r;
	r.onClick.obj = a;
	r.onClick.fn = &A::run; //wont work 
	r.Do();
}

#include <iostream>
#include <boost/function.hpp>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>

class A
{
public:
   void run(void) { std::cout << "A::run\n"; }
};

class R
{
public:
   boost::function<void()> onClick;

   void Do()
   {
      onClick();
   }
};


void ok()
{
   std::cout << "ok\n";
}

int main(int argc, char* argv[])
{

   A a;

   R r;
   r.onClick = ok;
   r.Do();
   using namespace boost::lambda;
   r.onClick = bind(&A::run, var(a));
   r.Do();
}

class SomeClass;

typedef void (SomeClass::* SomeClassFunction)(void);

void Invoke(SomeClass *pClass, SomeClassFunction funcptr) {
  (pClass->*funcptr)(); };

dehseth wrote:

I do not need boost for that

((a).*(m))();

(a.*(m))();

Richard Andrew x64 wrote:

Excellent answer, as usual

class A{
	public:	void run(void);
};

class R{
public:	

	typedef void (A::*Method)();
	Method onClick;	

	void Do(A* a)	
	{		
		(a->*onClick) ();	
	}
};

int _tmain(int argc, _TCHAR* argv[])
{	
	printf("main\n");		
	A a;	
	R r;	
	r.onClick = &A::run;
	r.Do(&a);...
}

C c;<br />
c.method();

class T
{
public:
	virtual void run() = 0; // this does not have to be abstract if you don't like, but it saves some bits
	virtual void run1() = 0; // another possible event 
};

class A : public T
{
	public:	
		void run(){ // A version
		};

		void run1(){ // A version
		};
};

class F : public T
{
	public:	
		void run(){ // F version
		};

		void run1(){ // F version
		};
};

class R{
	public:	

	typedef void (T::*Method)(); // general abstract method used, it can point to any method without parameters
	Method onClick;	

	void Do(T* t) // abstract type used
	{		
		(t->*onClick)();	
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	A a;	// create object A
	F f;	// create object F

	R r;	
	r.onClick = &T::run; // set one general event

	// now different type passed leads to different call
	r.Do(&a); // A::run called
	r.Do(&f); // F::run called

	r.onClick = &T::run1; // set another general event

	// again different type passed leads to different call
	r.Do(&a); // A::run1 called
	r.Do(&f); // F::run1 called

	...

Ric Ashton wrote:

I'm assuming your running a few thousand records.