Callback在C/C++中的实现

Callback是这样的一类对象(在这里不能简单的理解为"回调函数"了):你注册一个函数,以及调用它时的参数,希望在满足某个条件时,以这些注册的函数调用这个回调,完成指定的操作.

很多地方会使用到这个概念.比如,UI程序中,注册一个函数,当某个鼠标事件发生的时候自动调用;比如,创建一个线程,线程开始运行时,执行注册的函数操作.
Callback的出现,本质上是因为很多操作都有异步化的需要---你不知道它什么时候会执行,只需要告诉它,在执行的时候,调用我告诉你的操作即可.
尽管使用的地方不尽相同,但是从程序的角度上看,做的事情都是差不多的.

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

简单介绍一下目前我所知道的几种方法,有C++的,也有C的.

1) 使用模板
将不同参数的类型,作为模板的参数.比如:

#include  < stdio.h >

class  Closure 
{
public:
  virtual ~Closure(){}
  virtual void Run() {}

protected:
  Closure(){}
} ;

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, T1>(obj, member, P);
}

int  main()
{
  Test test;

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

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

  return 0;
}

在这里,定义了一个虚拟基类Closure,它对外暴露一个接口Run,也就是,使用它的时候只需要使用Closure指针->Run即可以执行注册的操作.需要注意的是,Closure的构造函数声明为protected,也就是仅可以被子类调用.
接下来,定义的Closure'子类都是模板类,其中的模板都是参数,我分别实现了两种子类,分别是不带参数的和带一个参数的.将回调函数需要的参数,保存在具体的子类对象中.
最后,对外构造一个Closure指针时,最好也提供一致的接口,这里分别为两种子类实现了NewCallback函数.
剩下的,理解起来应该不难.

这种实现方法,看明白的就知道,其实难点不多.它将回调函数和传递给回调函数的参数放在了一个类中,当外部调用Run接口的时候,再根据内部的实现来具体进行操作.
但是,我本人很不喜欢模板满天飞的代码,所以应该还有些别的方法来实现吧?

2) 不使用模板,将参数和回调分离,分别对参数和回调进行抽象
CEGUI是一款开源的游戏UI项目,早几年我还在做着3D引擎程序员梦的时候,曾经看过一些,对它的一些代码还有些印象.
里面对UI事件的处理,也使用了类似Callback的机制(这种使用场景最开始的时候曾经说过,所以应该不会感到意外).
在CEGUI中,一个事件由一个虚拟基类Event定义,处理事件的时候调用的是它的纯虚函数fireEvent,而这个函数的参数之一是EventArgs--这又是一个虚拟基类.
所以,熟悉面向对象的人,应该可以很快的反应过来了:在Event的子类中实现fireEvent,而不同的函数参数,可以从EventArgs虚拟基类中派生出来.
于是,具体回调的时候,仅仅需要调用 Event类指针->fireEvent(EventArgs类指针)就可以了.
(我在这里对CEGUI的讲解,省略了很多细节,仅仅关注到最关注的点,感兴趣的可以自己去看看代码)

对比1)和2)两种解决方法,显然对我这样不喜欢模板的人来说,更喜欢2).除了模板的代码读起来比较头大,以及模板会让代码量增大之外.喜欢2)的原因还在于,C对"类模板"机制的支持实在是欠缺,至今除了使用宏之外,似乎找不到很好的办法能够实现类C++的模板机制.但是,如果采用2)的继承接口的方式,C就可以很清楚的实现出来.所以就有了下面C的实现:

3) C的实现.
有了2)的准备,使用C来实现一个类似的功能,应该很容易了,下面贴代码,应该很清楚的:

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef struct event
{
  void (*fireEvent)(void *arg);
  void *arg;
}event_t;

typedef struct event_arg1
{
  int value;
}event_arg1_t;

void fireEvent_arg1(void *arg)
{
  event_arg1_t *arg1 = (event_arg1_t*)arg;

  printf("arg 1 = %d/n", arg1->value);
}

#define NewEvent(event, eventtype, callback)      /
  do {                                            /
      *(event) = (event_t*)malloc(sizeof(event_t)); /
      assert(*(event));                              /
      (*(event))->arg = (eventtype*)malloc(sizeof(char) * sizeof(eventtype)); /
      assert((*(event))->arg);                         /
      (*(event))->fireEvent = callback;             /
  } while (0)

#define DestroyEvent(event)                       /
  do {                                            /
    free((*(event))->arg);                        /
    free(*(event));                               /
  } while(0)      

int main()
{
  event_t *event;

  NewEvent(&event, event_arg1_t, fireEvent_arg1);
  ((event_arg1_t*)(event->arg))->value = 100;
  event->fireEvent(event->arg);

  DestroyEvent(&event);

  return 0;
}

 

 

转自 http://www.cppblog.com/converse/archive/2010/04/19/113023.html