首页 › UC › Callback在C/C++中的实现

Callback在C/C++中的实现

第七根弦 2015 年 1 月 7 日 UC 发表评论 (0)

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

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

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

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

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

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
#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来实现一个类似的功能,应该很容易了,下面贴代码,应该很清楚的:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#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;
}

adfadfsdaf
adfadfsdaf
adfadfsdaf
adfadfsdaf
adfadfsdaf
adfadfsdaf
adfadfsdaf

|

发表评论