C++ 回调函数理解

http://blog.csdn.net/clirus/article/details/50350519

编程中肯定会遇到在C++中使用回调函数的情况。

但是为什么要使用回调函数呢？我们需要理解回调函数设计原理

因为可以把调用者与被调用者分开。调用者不关心谁是被调用者，所有它需知道的，只是存在一个具有某种特定原型、某些限制条件（如返回值为int）的被调用函数。
如果想知道回调函数在实际中有什么作用，先假设有这样一种情况，我们要编写一个库，它提供了某些排序算法的实现，如冒泡排序、快速排序、shell排序、shake排序等等，但为使库更加通用，不想在函数中嵌入排序逻辑，而让使用者来实现相应的逻辑；或者，想让库可用于多种数据类型（int、float、string），此时，该怎么办呢？可以使用函数指针，并进行回调。

回调可用于通知机制，例如，有时要在程序中设置一个计时器，每到一定时间，程序会得到相应的通知，但通知机制的实现者对我们的程序一无所知。而此时，就需有一个特定原型的函数指针，用这个指针来进行回调，来通知我们的程序事件已经发生。实际上，SetTimer() API使用了一个回调函数来通知计时器，而且，万一没有提供回调函数，它还会把一个消息发往程序的消息队列。

另一个使用回调机制的API函数是EnumWindow()，它枚举屏幕上所有的顶层窗口，为每个窗口调用一个程序提供的函数，并传递窗口的处理程序。如果被调用者返回一个值，就继续进行迭代，否则，退出。EnumWindow()并不关心被调用者在何处，也不关心被调用者用它传递的处理程序做了什么，它只关心返回值，因为基于返回值，它将继续执行或退出。

不管怎么说，回调函数是继续自C语言的，因而，在C++中，应只在与C代码建立接口，或与已有的回调接口打交道时，才使用回调函数。除了上述情况，在C++中应使用虚拟方法或函数符（functor），而不是回调函数。

如果你不想封装一个C接口来进行回调，那必须通过C++的方式实现回调。

回调函数的原理不在赘述，无非就是传入一个函数地址，然后在达到某种情况的时候，可以通过这个函数地址调用用户（此用户指回调函数的使用者）希望的函数接口，继而传递参数，所以回调函数的实现是比较简单的，只需要将函数地址保存，然后触发调用即可。

那我们就说明一下在C++中回调函数的使用。

在C++中，如何使用类的成员函数作为回调函数入参呢？我们先理解一下C++静态成员函数。

在C++中普通成员函数和静态成员函数的区分如下：

1、静态成员函数的地址可用普通函数指针储存，而普通成员函数地址需要用 类成员函数指针来储存。举例如下： 

[cpp]  view plain  copy

1. class base{   
2. static int func1();   
3. int func2();   
4. };   

[cpp]  view plain  copy

1. int (*pf1)()=&base::func1;//普通的函数指针   
2. int (base::*pf2)()=&base::func2;//成员函数指针   

2、 静态成员函数不可以调用类的非静态成员。静态成员函数不含this指针，而普通成员函数默认携带this指针参数。

有了以上区分，则我们可以知道只能 原则上只能是静态成员函数作为回调函数的入参，但是我们依旧可以做些变化，可以对成员函数的指针类型进行强转。

废话不多说，下面是C++调用C的回调函数的例子：

1、非静态成员函数作为回调函数参数例子

非静态成员函数作为回调函数参数的天生弊端已经在上面对比中讲清楚，所以我们回调函数的设计必须要能够满足非静态成员函数的情况。

回调函数：（我们采用C方式实现回调函数，和C++并没有什么区别）

[cpp]  view plain  copy

1. typedef struct  
2. {  
3.     int aa;  
4.     int bb;  
5. }testMsgType;  
6.   
7. // 回调函数指针定义 void*用来保存this指针  
8. typedef int (*ptestCB)( testMsgType *, void *);  
9. ptestCB m_test; // 保存回调函数地址  
10. void* m_kk;// 保存this指针  
11. // 回调函数  
12. int setCBTest(ptestCB pf, void * kk)  
13. {  
14.     printf("wei....... set cb ok!!!\n");  
15.     m_test = pf;  
16.     m_kk = kk;  
17.     return 0;  
18. }  
19.   
20. int cbfuc()  
21. {  
22.     printf("cb func !!!\n");  
23.     stZigBeeMsg* type = new testMsgType;  
24.     m_test(type,m_kk); // 调用回调函数  
25.     return 0;  
26. }  

回调函数调用：

[cpp]  view plain  copy

1. Caa.h  
2. class Caa  
3. {  
4. public:  
5.      Caa();  
6.     ~Caa();  
7.     init();  
8.     // 类的非静态成员函数作为回调函数参数  
9.     int onmycb(stZigBeeMsg *  p,void* kk);  
10.     int dealCB(ptestCB* p);  
11. }  

[cpp]  view plain  copy

1. Caa.c  
2. Caa::Caa()  
3. {  
4.     init();  
5. }  
6.   
7. Caa::~Caa()  
8. {  
9. }  
10. bool Caa::init()  
11. {  
12.     // 设置回调函数  
13.     // 需要将成员函数的this指针传入  
14.     // 需要将类成员函数地址强制转换为回调函数类型  
15.     setCBTest((ptestCB)&Caa::onmyevent,this);  
16.     return true;  
17. }  
18. // 回调函数  
19. int Caa::onmyevent(testMsgType *  p,void* aa)  
20. {  
21.     // 将回调回来的指针强制转换为类指针，然后调用类的成员函数  
22.     ((CEventMgmt*)aa)->dealCB(p);  
23.     return 0;  
24. }  
25. // 业务处理函数  
26. int Caa::dealCB(testMsgType* p)  
27. {  
28.       return 0;  
29. }  

2、静态成员函数作为回调函数参数，非静态类

静态成员函数作为回调函数参数时，因为静态成员函数没有this指针，所以回调函数的设计比较简单，不用包含void *来传递保存this指针。

回调函数：

[cpp]  view plain  copy

1. // 回调函数指针定义 不用包含void *  
2. typedef int (*ptestCB)( stZigBeeMsg *);   
3. // 保存回调函数地址  
4. ptestCB m_test;   
5.   
6. int setCBTest(ptestCB pf)  
7. {  
8.     printf(" set cb ok!!!\n");  
9.     m_test = pf;  
10.     return 0;  
11. }   
12.   
13. int cbfuc()  
14. {  
15.     printf("cb func !!!\n");  
16.     testMsgType* type = new testMsgType;  
17.     m_test(type);  
18.     return 0;  
19. }  

回调函数调用：

[cpp]  view plain  copy

1. Caa.h  
2. class Caa  
3. {  
4. public:  
5.      Caa();  
6.     ~Caa();  
7.     init();  
8. private:  
9.     //设置当前对象为回调函数调用的对象   
10.     void setCurClass()    
11.     {   
12.         spCB = this;   
13.     }    
14.     static int onmycb(stZigBeeMsg *  p);  
15.     int dealCB(ptestCB* p);  
16. private:  
17.     static Caa* spCB;//存储回调函数调用的对象  
18. }  

Caa.c

[cpp]  view plain  copy

1. Caa* Caa::spCB = NULL;  
2. Caa::Caa()  
3. {  
4.     init();  
5. }  
6.   
7. Caa::~Caa()  
8. {  
9. }  
10. bool Caa::init()  
11. {  
12.     // 将spCB设置为this供回调使用  
13.     setCurClass();  
14.     // 设置回调函数  
15.     // 需要将成员函数的this指针传入  
16.     // 需要将类成员函数地址强制转换为回调函数类型  
17.     setCBTest(&Caa::onmyevent);  
18.     return true;  
19. }  
20. // 回调函数  
21. int Caa::onmyevent(testMsgType *  p)  
22. {  
23.     // 将回调回来的指针强制转换为类指针，然后调用类的成员函数  
24.     spCB->dealCB(p);  
25.     return 0;  
26. }  
27. // 业务处理函数  
28. int Caa::dealCB(testMsgType* p)  
29. {  
30.     return 0;  
31. }   

3、静态成员函数作为回调函数参数，采用单例设计模式

和上面的例子思路是一致的，上面采用一个类的静态对象来做中间转换，继而调用非静态成员函数。

那么假如我设计类为单例模式，则直接可以在静态成员函数回调内部进行调用非静态成员函数，如下：

先设置类为单例

[cpp]  view plain  copy

1. Caa * Caa::instance()  
2. {  
3.     static Caa *p;  
4.     if (p == NULL)  
5.     {  
6.         p = new Caa;  
7.     }  
8.     return p;  
9. }  

然后在回调函数内部可以采用：

[cpp]  view plain  copy

1. int Caa::onmyevent(testMsgType *  p)  
2. {  
3.     // 将回调回来的指针强制转换为类指针，然后调用类的成员函数  
4.      Caa::instance()->dealCB(p);  
5.     return 0;  
6. }  

这样即可达到例子2中的效果。

其实在C++中使用回调函数，只有明白两个基础知识点即可：

1、回调函数设计原理

2、静态成员函数和非静态成员函数区别