理解函数指针和回调函数

理解

函数指针

指向函数的指针。比如：
理解函数指针的伪代码

1. void (*p)(int type, char *data); // 定义一个函数指针p
2. void func(int type, char *data); // 声明一个函数func
3. p = func; // 将指针p指向函数func
4. p(1,"test"); // 调用方式1
5. (*p)(1,"test"); // 调用方式2

复制代码

回调函数和回调

比如，B把自己函数cbkFunc()的地址告诉A，A在运行过程中执行cbkFunc()。则
回调函数：指B的函数cbkFunc()；
注册回调函数：指B把函数cbkFunc()的地址告诉A；
回调：指A在运行过程中执行cbkFunc()。
code

• 无头文件.h
  
• 为了方便模块A和B写在了一个.c文件中
  
• 打印log的函数见参考博客[3]，可以直接替换为printf()
  

FunctionPointTest.c

1. /*
2. * 理解函数指针和回调函数
3. *
4. * 假设需求：A要进行某项运动，有开始、正在做、结束3个状态，
5. * B需要关注这3个状态
6. *
7. * 实现方案：A提供一个回调函数注册接口，在程序开始运行时，
8. * B向A注册回调函数，A以回调函数的形式通知B
9. *
10. * 为了简便A和B写在一个文件里
11. */
13. #include "D:\MyFiles\MyLog\WindowsC\mylog.h"
14. #include <stdio.h>
15. #include <windows.h>
17. // A和B的共同定义,一般是A的一个头文件，B会包含这个头文件：
18. typedef enum ENUM_EVENT {
19.         E_EVENT_START,
20.         E_EVENT_DOING,
21.         E_EVENT_FINISH,
22. } EnumEvent;
23. typedef void (*EVENT_CBK)(EnumEvent type, char *data);
24. int regEventCbk(EVENT_CBK cbk);
26. // A的实现
27. #define TAGA "[MODULE_A]"
28. static EVENT_CBK gSendEvent = NULL;
29. int regEventCbk(EVENT_CBK cbk) {
30.         if (cbk == NULL) {
31.                 return -1;
32.         }
33.         gSendEvent = cbk;
34.         LOGI("%s{有人注册了回调函数:%X, 地址:%p}", TAGA, *gSendEvent, gSendEvent);
35.         return 0;
36. }
37. void doing() {
38.         gSendEvent(E_EVENT_DOING, "进行中..."); // 调用方式1
39.         Sleep(1000);
40. }
41. void runA() {
42.         LOGI("%s{我是A}", TAGA);
43.         if (gSendEvent == NULL) {
44.                 LOGW("%s{B不关心我}", TAGA);
45.                 return;
46.         }
47.         (*gSendEvent)(E_EVENT_START, "我开始了哟"); // 调用方式2
48.         doing();
49.         (*gSendEvent)(E_EVENT_FINISH, "我好了");
50. }
52. // B的实现
53. #define TAGB "[MODULE_B]"
54. long long int gAStart = 0;
55. long long int gAFinish = 0;
56. void eventStartHandler(char *data) {
57.         gAStart = GetTickCount();
58.         LOGI("%s{A:%s}{%lld}", TAGB, data, gAStart);
59. }
60. void eventDoingHandler(char *data) {
61.         LOGI("%s{A:%s}", TAGB, data);
62. }
63. void eventFinishHandler(char *data) {
64.         long long int aDurS = 0;
65.         gAFinish = GetTickCount();
66.         LOGI("%s{A:%s}{%lld}", TAGB, data, gAFinish);
68.         aDurS = (gAFinish - gAStart)/1000;
69.         LOGI("%s{A %llds}", TAGB, aDurS);
70.         if (aDurS < 10) {
71.                 LOGI("%s{A 真快}", TAGB);
72.         }
73. }
74. void onEvent(EnumEvent type, char *data) {
75.         switch (type) {
76.                 case E_EVENT_START:
77.                         eventStartHandler(data);
78.                 break;
79.                 case E_EVENT_DOING:
80.                         eventDoingHandler(data);
81.                 break;
82.                 case E_EVENT_FINISH:
83.                         eventFinishHandler(data);
84.                 break;
85.                 default:
86.                 break;
87.         }
88. }
89. void careA() {
90.         LOGI("%s{我的回调函数地址:%p}", TAGB, onEvent);
91.         regEventCbk(onEvent);
92. }
93. void runB() {
94.         LOGI("%s{我是B}", TAGB);
95.         careA();
96. }
101. int main() {
102.         LOGI("{start}");
103.         runB();
104.         runA();
105.         return 0;
106. }

复制代码

运行结果


可优化点

.
参考博客

[1] https://zhuanlan.zhihu.com/p/162578969
[2] https://blog.csdn.net/zhou8201/article/details/100700479
[3] https://blog.csdn.net/qq_31300101/article/details/130190026?spm=1001.2014.3001.5502

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！