什么是回调函数

友情提示：原理介绍部分摘自：https://www.jianshu.com/p/2f695d6fd64f

有一定基础的直接跳过即可，直接查看后面精彩部分...

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

一幅图来说明什么是回调：

结合这幅图和上面对回调函数的解释，我们可以发现，要实现回调函数，最关键的一点就是要将函数的指针传递给一个函数(上图中是库函数)，然后这个函数就可以通过这个指针来调用回调函数了。注意，回调函数并不是C语言特有的，几乎任何语言都有回调函数。在C语言中，我们通过使用函数指针来实现回调函数。那函数指针是什么？不着急，下面我们就先来看看什么是函数指针。

什么是函数指针

函数指针也是一种指针，只是它指向的不是整型，字符型而是函数。在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则是用了 * 对函数指针取值，从而实现对函数的调用。

将函数指针作为参数传给函数

函数指针和普通指针一样，我们可以将它作为函数的参数传递给函数，下面我们看看如何实现函数指针的传参：

/* 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(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;
}

第二步

我们需要定义四个函数指针分别指向这四个函数：

/****************************************
 * 函数指针结构体
 ***************************************/
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 = ÷
}

第三步

我们需要创建一个“库函数”，这个函数以函数指针为参数，通过它来调用不同的函数：

/****************************************
 * 库函数
 ***************************************/
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);

使用的时候，我们只需要把串口解析处理逻辑放在对应的回调函数中处理即可

拿串口接收来举例,定义的是一个弱函数，我们在自己的文件中重新实现就好

/**
  * @brief  Rx Transfer completed callbacks.
  * @param  huart pointer to a UART_HandleTypeDef structure that contains
  *                the configuration information for the specified UART module.
  * @retval None
  */
__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_t timeout;    //表示到计数值了
 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;
 return SOFT_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 的句柄，
 */
static c_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)
 {
  return soft_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);
}

static void 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){
    case cmd1:
        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_t len);
} _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])
            {
              /*
                            处理逻辑
             */
            }
        }
    }
}

二者相比有什么区别呢？假设我们需要新增几个命令码，第一种方式，我们就需要在主函数中去改变，看一堆代码，很容易误操作影响代码的整体结构，但第二种就不会，我们只需要在结构体中新增命令和回调函数即可，主运行逻辑不需要去修改，大大降低代码的可维护性。