那谁的技术博客

感兴趣领域:高性能服务器编程,存储,算法,Linux内核
随笔 - 210, 文章 - 0, 评论 - 1183, 引用 - 0
数据加载中……

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;
}

posted on 2010-04-19 22:45 那谁 阅读(19194) 评论(12)  编辑 收藏 引用 所属分类: C\C++

评论

# re: Callback在C\C++中的实现  回复  更多评论   

stl的function<T>解决所有问题
2010-04-20 07:48 | 陈梓瀚(vczh)

# re: Callback在C\C++中的实现[未登录]  回复  更多评论   

我也做过.我觉得适合自己的项目需求就OK啦
new CallBack<void (Test::*)(Event*)> (this, &Test::MemberFun);

new CallBack<void (*)(Event*)> (&g_func);
2010-04-20 08:26 | ~

# re: Callback在C\C++中的实现  回复  更多评论   

C/C++对参数个数和类型太苛刻的缘故,我对复杂的方案都没什么兴趣。
最喜欢的还是fn_callback(void* ctx)
2010-04-20 09:06 | LOGOS

# re: Callback在C\C++中的实现  回复  更多评论   

@LOGOS
std::function<T>用起来非常简单
2010-04-20 12:50 | 陈梓瀚(vczh)

# re: Callback在C\C++中的实现  回复  更多评论   

我觉得这种做法是把简单的问题复杂化了。

在决定使用 函数指针/回调函数 来作为我们的实现方案的时候,我们要考虑的事情是:
1. 由注册函数的人来决定这个函数被调用时的参数。 还是,
2. 由这个函数的将来的调用者来决定该函数的参数。

如果是1, 则局限性比2要大,因为在注册函数的时候,并不完全清楚在函数调用时的实际情况,所以在某些场合,提前设定好了参数,到了实际调用的场合,这些参数有可能不合适。
而2,完全是由调用者根据实际情况来决定用什么样的参数来传递到调用函数中,灵活性更强。而这种场合,编码实现也最简单,无非就是一个函数指针而已。
而往往,函数的注册者和函数的调用者几乎都是一个人/用户, 所以为何非要提前来决定这个函数的调用参数,而让问题的实现变得更加复杂呢。
我认为这得不偿失。而,在商业软件开发中,很少会为了1的情况,而增加额外的测试,代码检视的成本。

可以参考linux内核的文件系统的实现。其中,VFS和实际文件系统之间的接口,就是利用了简单的函数指针,代码并不像1那么复杂。
2010-04-21 10:27 | lymons

# re: Callback在C\C++中的实现  回复  更多评论   

std::function<T>这完硬怎么当回调函数用?
2010-04-27 18:49 | coder

# re: Callback在C\C++中的实现  回复  更多评论   

很不错的文章,只是我已经不写代码很多年。
2010-05-18 17:04 | 某人

# re: Callback在C\C++中的实现[未登录]  回复  更多评论   

你这个接口设计的不是很友好,使用比较麻烦。我以前写过一个接口。你可以参考一下
http://www.cnblogs.com/Aplo/archive/2007/09/07/886145.html
2010-05-20 22:19 | aplo

# re: Callback在C\C++中的实现  回复  更多评论   

第一种方法中把参数做为Test的成员存储起来,调用的方法不带参数,直接取成员应该更好一些吧!
2010-12-30 15:41 | 匿名

# re: Callback在C\C++中的实现  回复  更多评论   

难得好文
2013-12-30 15:12 | halleyzhang3

只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理