c++实现Callback机制

 Callback的出现,本质上是因为很多操作都有异步化的需要---你不知道它什么时候会执行,只需要告诉它,在执行的时候,调用我告诉你的操作即可.尽管使用的地方不尽相同,但是从程序的角度上看,做的事情都是差不多的。

 要实现一个Callback,最大的难点在于,变化的参数和需要统一的对外接口之间的矛盾.也就是说,回调函数执行时参数的数量是你无法预知的.而你需要对外提供一个统一的接口,调用该接口的不需要关注到注册进去的到底是什么,有几个参数,具体的执行留到回调真正执行的时候再去处理。

 下面给出一段程序加以理解：

#include <stdio.h>
class Closure
{
public:
	virtual ~Closure(){}
	virtual void Run(){}
protected:
	Closure(){} //构造函数是protected，只能被子类调用
};

template<class T>
class Callback0 : public Closure
{
public:
	typedef void (T::*Done)();
public:
	Callback0(T *obj, Done run) : object_(obj), run_(run)
	{

	}

	virtual void Run()
	{
		(object_->*run_)();
	}
private:
	T *object_;
	Done run_;
};

template<class T, class T1> 
class Callback1 
  : public Closure 
{ 
public: 
  typedef void (T::*Done)(T1); 
  
public:  
  Callback1(T *obj, Done run, T1 arg) 
    : object_(obj) 
    , run_(run) 
    , arg0_(arg) 
  { 
  }

  virtual void Run() 
  { 
    (object_->*run_)(arg0_); 
  } 
private: 
  T *object_; 
  Done run_; 
  T1 arg0_; 
};

class Test 
{ 
public: 
  void Run0() 
  { 
    printf("in Test::Run0/n"); 
  }

  void Run1(int i) 
  { 
    printf("in Test::Run1/n"); 
  } 
};

template<class T>
Closure* NewCallback(T *obj, void (T::*member)())
{
	return new Callback0<T>(obj, member);
}

template<class T, class T1>
Closure* NewCallback(T *obj, void (T::*member)(T1), T1 P)
{
	return new Callback1<T>(obj, member, P);
}

int main()
{
	Test test;
	Closure *closure0 = NewCallback(&test, &Test::Run0);
	callback0->Run();
	delete callback0;

	Closure *calback1 = NewCallback(&test, &Test::Run1, 1);
	callback1->Run();
	delete callback1;

	return 0;
}