甚么是反弹表达式
反弹表达式是两个透过表达式操作符初始化的表达式。假如你把表达式的操作符（门牌号）做为HTA给另两个表达式，当那个操作符被用以初始化其所对准的表达式时，他们就说这是反弹表达式。反弹表达式并非由该表达式的同时实现方间接调用，而要在某一的该事件或前提出现时由除此之外的另一方初始化的，用作对该该事件或前提展开积极响应。
两幅图来表明甚么是反弹：
紧密结合梵高图和上直面反弹表达式的表明，他们能辨认出，要同时实现反弹表达式，最关键性的一点儿是要将表达式的操作符传递给两个表达式(左图中是库表达式)，接着那个表达式就能透过那个操作符来初始化反弹表达式了。特别注意，反弹表达式并并非C词汇独有的，基本上任何人词汇都有反弹表达式。在C词汇中，他们透过采用表达式操作符来同时实现反弹表达式。那表达式操作符是甚么？不心急，上面他们就嘿嘿看一看甚么是表达式操作符。
甚么是表达式操作符
表达式操作符也是一类操作符，而已它对准的并非auth，字符串型而要表达式。在C中，每一表达式在校对后都是储存在缓存中，因此每一表达式都有两个出口处门牌号，依照这个门牌号，他们便能出访并采用那个表达式。表达式操作符是透过对准那个表达式的出口处，进而初始化那个表达式。
表达式操作符的表述
表达式操作符尽管也是操作符，但它的表述形式却和其它操作符看起来很不那样，他们来看一看它是怎样表述的：
/* 形式1 */ void (*p_func)(int, int, float) = NULL; /* 形式2 */ typedef void (*tp_func)(int, int, float); tp_func p_func =NULL;这两种形式都是表述了两个对准返回值为 void 类型，参数为 (int, int, float) 的表达式操作符。第二种形式是为了让表达式操作符更容易理解，尤其是在复杂的环境下；而对于一般的表达式操作符，间接用第一类形式就行了。
表达式操作符的赋值
在表述完表达式操作符后，他们就需要给它赋值了他们有两种形式对表达式操作符展开赋值：
void (*p_func)(int, int, float) = NULL; p_func = &func1; p_func = func2;复制
上面两种形式都是合法的，对于第二种形式，校对器会隐式地将 func_2 由 void ()(int, int, float) 类型转换成 void (*)(int, int, float) 类型，因此，这两种形式都行。想要了解更详细的表明，能看一看上面那个stackoverflow的链接。
采用表达式操作符初始化表达式
因为表达式操作符也是操作符，因此能采用常规的带 * 的形式来初始化表达式。和表达式操作符的赋值那样，他们也能采用两种形式：
/* 形式1 */ int val1 = p_func(1,2,3.0); /* 形式2 */ int val2 = (*p_func)(1,2,3.0);形式1和他们平时间接初始化表达式是那样的，形式2则是用了 * 对表达式操作符取值，进而同时实现对表达式的初始化。
将表达式操作符做为参数传给表达式
表达式操作符和普通操作符那样，他们能将它做为表达式的HTA给表达式，上面他们看一看怎样同时实现表达式操作符的传参：
/* func3 将表达式操作符 p_func 做为其形参 */ void func3(int a, int b, float c, void(*p_func)(int, int, float)) { (*p_func)(a, b, c); } /* func4 初始化表达式func3 */ void func4() { func3(1, 2, 3.0, func_1); /* 或者 func3(1, 2, 3.0, &func_1); */ }表达式操作符数组
在开始讲解反弹表达式前，最后介绍一下表达式操作符数组。既然表达式操作符也是操作符，那他们就能用数组来存放表达式操作符。上面他们看两个表达式操作符数组的例子：
/* 形式1 */ void (*func_array_1[5])(int, int, float); /* 形式2 */ typedef void (*p_func_array)(int, int, float); p_func_array func_array_2[5];上面两种形式都能用以表述表达式操作符数组，它们表述了两个元素个数为5，类型是 void (*)(int, int, float) 的表达式操作符数组。
反弹表达式
他们前面谈的都是表达式操作符，现在他们回到正题，来看一看反弹表达式到底是怎样同时实现的。上面是两个四则运算的简单反弹表达式例子：
#include <stdio.h> #include <stdlib.h> /**************************************** * 表达式操作符结构体 ***************************************/ typedef struct _OP { float (*p_add)(float, float); float (*p_sub)(float, float); float (*p_mul)(float, float); float (*p_div)(float, float); } OP; /**************************************** * 加减乘除表达式 ***************************************/ float ADD(float a, float b) { return a + b; } float SUB(float a, float b) { return a – b;} float MUL(float a, float b) { return a * b; } float DIV(float a, float b) { return a / b; } /**************************************** * 初始化表达式操作符 ***************************************/ void init_op(OP *op) { op->p_add = ADD; op->p_sub = SUB; op->p_mul = &MUL; op->p_div = &DIV; } /**************************************** * 库表达式 ***************************************/ float add_sub_mul_div(float a, float b, float (*op_func)(float, float)) { return (*op_func)(a, b);} int main(int argc, char *argv[]) { OP *op = (OP *)malloc(sizeof(OP)); init_op(op); /* 间接采用表达式操作符初始化表达式 */ printf(“ADD = %f, SUB = %f, MUL = %f, DIV = %f\n”, (op->p_add)(1.3, 2.2), (*op->p_sub)(1.3, 2.2), (op->p_mul)(1.3, 2.2), (*op->p_div)(1.3, 2.2)); /* 初始化反弹表达式 */ printf(“ADD = %f, SUB = %f, MUL = %f, DIV = %f\n”, add_sub_mul_div(1.3, 2.2, ADD), add_sub_mul_div(1.3, 2.2, SUB), add_sub_mul_div(1.3, 2.2, MUL), add_sub_mul_div(1.3, 2.2, DIV)); return 0; }那个例子有点长，我一步步地来讲解怎样采用反弹表达式。
第一步
要完成加减乘除，他们需要表述四个表达式分别同时实现加减乘除的运算功能，这几个表达式是:
/**************************************** * 加减乘除表达式 ***************************************/ float ADD(floata,float b) { return a + b; } float SUB(float a, float b) { return a – b; } float MUL(float a, float b) { returna * b; }float DIV(float a, float b) { return a / b; }第二步
他们需要表述四个表达式操作符分别对准这四个表达式：
/**************************************** * 表达式操作符结构体 ***************************************/ typedef struct _OP { float (*p_add)(float, float); float (*p_sub)(float, float); float (*p_mul)(float, float); float (*p_div)(float, float); } OP; /**************************************** * 初始化表达式操作符 ***************************************/ void init_op(OP *op) { op->p_add = ADD; op->p_sub = SUB; op->p_mul = &MUL; op->p_div = &DIV; }第三步
他们需要创建两个“库表达式”，那个表达式以表达式操作符为参数，透过它来初始化不同的表达式：
/**************************************** * 库表达式 ***************************************/ float add_sub_mul_div(float a, float b, float (*op_func)(float, float)) { return (*op_func)(a, b); }第四步
当这几部都完成后，他们就能开始初始化反弹表达式了：
/* 初始化反弹表达式 */ printf(“ADD = %f, SUB = %f, MUL = %f, DIV = %f\n”, add_sub_mul_div(1.3, 2.2, op->p_add), add_sub_mul_div(1.3, 2.2, op->p_sub), add_sub_mul_div(1.3, 2.2, MUL), add_sub_mul_div(1.3, 2.2, DIV));简单的四步便能同时实现反弹表达式。在这四步中，他们甚至能省略第二步，间接将表达式名传入“库表达式”，比如上面的乘法和除法运算。反弹表达式的核心是表达式操作符，只要搞懂了表达式操作符再学反弹表达式，那真是手到擒来了。
反弹表达式在嵌入式系统中的应用
在stm32的HAL库中，是采用了大量的反弹表达式的，串口、定时器等外设都是有对应的反弹表达式的，反弹监督机制能更好地分离代码，应用层和驱动层完全分离，降低耦合性。
简单来看几个例子：
串口反弹表达式：
void HAL_UART_IRQHandler(UART_HandleTypeDef *huart); void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart); void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart); void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart); void HAL_UART_RxHalfCpltCallback(UART_HandleTypeDef *huart); void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart); void HAL_UART_AbortCpltCallback (UART_HandleTypeDef *huart); void HAL_UART_AbortTransmitCpltCallback (UART_HandleTypeDef *huart); void HAL_UART_AbortReceiveCpltCallback (UART_HandleTypeDef *huart);采用的时候，他们只需要把串口解析处理逻辑放在对应的反弹表达式中处理即可
拿串口接收来举例,表述的是两个弱表达式，他们在自己的文件中重新同时实现就好
/** * @briefRx Transfer completed callbacks. *@paramhuart pointer to a UART_HandleTypeDef structure that contains * the configuration information for the specified UART module. *@retvalNone */ __weak void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) { /* Prevent unused argument(s) compilation warning */ UNUSED(huart); /* NOTE:This function Should not be modified, when the callback is needed, the HAL_UART_TxCpltCallback could be implemented in the user file */ }/** *@brief 串口中断反弹表达式 * * @param * @param * @retval none */void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {if(huart->Instance == USART1) { Voice_RecUartCallBack(); }else if (huart->Instance == USART2) { Voice_RecUartCallBack(); } }HAL库中的反弹思想是有了，但代码同时实现略微有点“嵌入式”，接下来看点“程序员”的写法，以他们之前介绍的软件定时器一文，紧密结合上面介绍的原理：
/* soft timer device */ typedef struct class_soft_timer { e_timer_work_mode_t mode; //工作模式 uint16_t cnt_aim; //目标计数值 uint16_t cnt_now; //当前的计数值 uint8_ttimeout;//表示到计数值了 uint8_t enable; //表示timer是否开启 struct class_soft_timer *timer_next; //对准下两个timer void *para; //反弹表达式的参数 soft_timer_call_back *timer_cb; //反弹表达式 } c_soft_timer_t;从上面的代码中他们能看到，软件定时器的一些参数设置和最后一项的反弹表达式
软件定时器实现的一些形式：
/* soft timer operate define */ typedef struct class_sotft_timer_operation { c_soft_timer_t*(*add_new_timer)(e_timer_work_mode_t mode, uint16_t tim, void *para, soft_timer_call_back tim_cb); //添加两个新的timer e_soft_timer_state_t (*delete_timer)(c_soft_timer_t *timer); //删除两个timer e_soft_timer_state_t(*timer_set_period)(c_soft_timer_t *timer, uint16_t period); //设置定时周期 e_soft_timer_state_t (*timer_reload_cnt)(c_soft_timer_t *timer, uint16_t tim_cnt); //重新设置计数值 e_soft_timer_state_t (*timer_heart)(void); //soft timer heart e_soft_timer_state_t (*timer_handle)(void); //soft timer handle e_soft_timer_state_t (*timer_start)(void); //soft timer module start e_soft_timer_state_t (*timer_stop)(void); //soft timer module stop e_soft_timer_state_t (*timer_enable)(c_soft_timer_t *timer); //timer enable e_soft_timer_state_t(*timer_disable)(c_soft_timer_t *timer); //timer disable } c_soft_timer_ops_t;看了上面的代码，跟开始的原理介绍找到了对应了吧，那么怎么采用呢？不慌，继续看…
在初始化中，他们把这些表述的表达式操作符对准他们实际同时实现的表达式即可：
/* * *@ author:lanxin * *@ brief:sotf timer module init * *@ note:初始化完成之后，就能采用全部的功能了 * *@ param:NONE * *@ retval:result != SOFT_TIMER_STATE_OK faild */ e_soft_timer_state_t fs_soft_timer_module_init(void) { /* creat timer operation index */ static c_soft_timer_ops_t *timer_ops_temp=0X00; timer_ops_temp=(c_soft_timer_ops_t*)malloc(sizeof(c_soft_timer_ops_t)); if(timer_ops_temp != 0x00) { /* add soft timer operate function*/timer_ops_temp->add_new_timer=add_new_timer; timer_ops_temp->delete_timer=delete_timer; timer_ops_temp->timer_heart=fs_soft_timer_heart; timer_ops_temp->timer_handle=fs_soft_timer_handle; timer_ops_temp->timer_start=fs_soft_timer_module_start; timer_ops_temp->timer_stop=fs_soft_timer_module_stop; timer_ops_temp->timer_set_period=fs_timer_set_period; timer_ops_temp->timer_disable=fs_soft_timer_disable; timer_ops_temp->timer_enable=fs_soft_timer_enable; timer_ops_temp->timer_reload_cnt=fs_timer_reload_cnt; }/* creat timer manage index*/ c_soft_timer_manage_t *timer_manage_temp=0x00; timer_manage_temp=(c_soft_timer_manage_t *)malloc(sizeof(c_soft_timer_manage_t)); /* 添加信息 */ if(timer_manage_temp != 0x00) { timer_manage_temp->timer_head=0x00; timer_manage_temp->timer_total_num=0; timer_manage_temp->timer_module_enable=SOFT_TIMER_MODULE_START; soft_timer_manage=timer_manage_temp; }else { free(timer_manage_temp); free(timer_ops_temp);return SOFT_TIMER_STATE_ERR; } tim_ops=timer_ops_temp; returnSOFT_TIMER_STATE_OK; }举两个例子：
timer_ops_temp->add_new_timer=add_new_timer;他们只需要把要处理的逻辑放在以下表达式中即可，最后两个参数是传入的表达式，也即是将表达式操作符做为参数传给表达式：
/* * *@ author:lanxin * *@ brief:添加新的timer * *@ note:假如之后要操作那个定时器，就得保存下来timer句柄，不操作就不用管。 * *@ param:mode 工作模式 * *@ param:tim 定时周期 * *@ param:para 反弹表达式的参数 * *@ param:tim_cb 反弹表达式 * *@ retval:新的timer 的句柄， */ staticc_soft_timer_t*add_new_timer(e_timer_work_mode_t mode,uint16_t tim,void *para,soft_timer_call_back tim_cb) { if(fs_add_new_soft_timer(mode,tim,para,tim_cb) == SOFT_TIMER_STATE_OK) {returnsoft_timer_manage->timer_head->timer_next;//新添加的timer在timer 链表的第二个。 } return 0x00; }物联网编程中的反弹表达式应用
接下来看一看网络编程中的反弹表达式应用，以MQTT的采用为例，小飞哥是采用的rt-thread中的pahomqtt采用例子：
static int mqtt_start(int argc, char **argv) { /* init condata param by using MQTTPacket_connectData_initializer */MQTTPacket_connectData condata = MQTTPacket_connectData_initializer;static char cid[20] = { 0 }; if (argc != 1) { rt_kprintf(“mqtt_start –start a mqtt worker thread.\n”); return -1; } if (is_started) { LOG_E(“mqtt client is already connected.”); return -1; } … /* set event callback function */client.connect_callback = mqtt_connect_callback; client.online_callback = mqtt_online_callback; client.offline_callback = mqtt_offline_callback;/* set subscribe table and event callback */ client.messageHandlers[0].topicFilter = rt_strdup(MQTT_SUBTOPIC); client.messageHandlers[0].callback = mqtt_sub_callback; client.messageHandlers[0].qos = QOS1; /* set default subscribe event callback */client.defaultMessageHandler = mqtt_sub_default_callback; }/* run mqtt client */ paho_mqtt_start(&client); is_started = 1; return 0; } static void mqtt_sub_callback(MQTTClient *c, MessageData *msg_data) { *((char*)msg_data->message->payload + msg_data->message->payloadlen) =\0; LOG_D(“mqtt sub callback: %.*s %.*s”, msg_data->topicName->lenstring.len, msg_data->topicName->lenstring.data, msg_data->message->payloadlen, (char *)msg_data->message->payload); } staticvoid mqtt_sub_default_callback(MQTTClient *c, MessageData *msg_data) { *((char*)msg_data->message->payload + msg_data->message->payloadlen) =\0; LOG_D(“mqtt sub default callback: %.*s %.*s”, msg_data->topicName->lenstring.len, msg_data->topicName->lenstring.data, msg_data->message->payloadlen, (char*)msg_data->message->payload); }static void mqtt_connect_callback(MQTTClient *c) { LOG_D(“inter mqtt_connect_callback!”); } static void mqtt_online_callback(MQTTClient *c) { LOG_D(“inter mqtt_online_callback!”); } static void mqtt_offline_callback(MQTTClient *c) { LOG_D(“inter mqtt_offline_callback!”); }从以上代码中，他们能看到，代码为上线、离线、发布、订阅等每两个功能都设置了对应的反弹表达式，这样代码结构看起来会非常的清朗，便于维护，如需要修改某两个功能的逻辑，间接找到对应的反弹表达式，而并非看一大堆代码去找对应的功能。
反弹表达式在命令解析中应用思考
再想想，他们在数据逻辑处理中，一般会有很多的功能码，假如他们采用命令码和反弹表达式绑定的形式，那代码维护起来是并非很方便…
经典写法：
void poll_task(rt_uint8_t cmd, rt_uint8_t *msg, uint8_t len) { switch (cmd){ casecmd1: func1();break; case cmd2: func2(); break; case cmd3: func3(); break; case cmd4: func4(); break; default: default_func(); break; } }复制
假如采用命令和反弹表达式绑定的形式怎么写呢？
typedef struct { rt_uint8_t CMD; rt_uint8_t (*callback_func)(rt_uint8_t cmd, rt_uint8_t *msg, uint8_tlen); } _FUNCCALLBACK; _FUNCCALLBACK callback_list[]= { { cmd1,func_callback1}, { cmd2,func_callback2}, { cmd3,func_callback3}, { cmd4,func_callback41}, … };void poll_task(rt_uint8_t cmd, rt_uint8_t *msg, uint8_t len) { int cmd_indexmax = sizeof(callback_list) / sizeof(_FUNCCALLBACK); int cmd_index = 0; for(cmd_index =0; cmd_index < cmd_indexmax; cmd_index++) { if (callback_list[cmd_index].CMD == cmd) { if(callback_list[cmd_index]) {/* 处理逻辑 */ } } } }二者相比有甚么区别呢？假设他们需要新增几个命令码，第一类方式，他们就需要在主表达式中去改变，看一堆代码，很容易误操作影响代码的整体结构，但第二种就不会，他们只需要在结构体中新增命令和反弹表达式即可，主运行逻辑不需要去修改，大大降低代码的可维护性。
本文分享自微信公众号 – 嵌入式实验基地（zhibiqingchun_youth），作者：Embedded小飞哥
