手把手教你写函数指针与回调函数-c++ 函数指针

在我们平时开发STM32或者其它单片机时，我们经常都会用到原厂提供的固件库函数，固件库函数中有非常多回调函数。那么什么是回调函数呢？回调函数是作为参数传递给另一个函数的函数。接受回调作为参数的函数预计会在某个时间点执行它。回调机制允许下层软件层调用上层软件层定义的函数。

应用程序代码和硬件驱动程序之间的交互

硬件驱动程序是一个独立的可重用驱动程序，它不了解上面的层(用户应用程序)。硬件驱动程序提供API函数，允许用户应用程序将函数注册为回调。然后，此回调函数由硬件驱动程序作为执行的一部分进行调用。如果不使用回调，就会被编码为直接调用。这将使硬件驱动程序特定于特定的高级软件级别，并降低其可重用性。回调机制的另一个好处是，在程序执行期间可以动态更改被调用的回调函数。

一、函数指针

函数指针，顾名思义它就是一个指针，只不过它是一个函数指针，所以指向的是一个函数。类比一般的变量指针，指针变量，实质上是一个变量，只不过这个变量存放的是一个地址，在32位单片机中，任何类型的指针变量都存放的是一个大小为4字节的地址。

int   a; < = > void cal_sum(void);
int * p; < = > void (*func_ptr)(void);
p=&a;   < = > func_ptr= &cal_sum;

左边走义变量a，右边定义函数cal_sum;

左边定义int指针，右边定义func_ptr;

左边赋值指针，右边赋值函数指针;

可能这样大家还是不太清楚，我是搞嵌入式单片机的，有本事你在Keil中给我举一个例子啊？

可以啊，没问题，请看！

#include "sys.h"
#include "led.h"
#include "delay.h"
#include "usart.h"
uint8_t cal_sum(uint8_t a, uint8_t b)
{
    return a + b;
}
int main(void)
{
    delay_init();
    uart_init(9600);
    printf("www.zhiguoxin.cn\r\n");
    printf("微信公众号：果果小师弟\r\n");
    uint8_t a = 10;
    uint8_t b = 8;
    /*定义一个函数指针*/
    uint8_t (*func_ptr)(uint8_t, uint8_t);
    /*将函数名赋值给函数指针*/
    func_ptr = cal_sum;
    printf("cal_sum_address  =0x%p\r\n", cal_sum);
    printf("func_ptr_address =0x%p\r\n", func_ptr);
    printf("%d + %d = %d\r\n", a, b, cal_sum(a, b));
    printf("%d + %d = %d\r\n", a, b, func_ptr(a, b));
    while(1)
    {
    }
}

这样写大家应该很熟悉吧，我首先定义了一个函数指针func_ptr，接着将我写得cal_sum函数赋值给了函数指针func_ptr 。然后分别打印函数cal_sum的地址，函数指针func_ptr的地址，以及使用cal_sum计算出来的值，和函数值指针func_ptr计算出来的值。

那么结果是啥样呢？

可以发现函数指针func_ptr和cal_sum函数的存储的地址以及他们所计算出来的值是一样的。

比如在上面求两个数和的基础上再求两个数的乘积和差，会是啥样的呢？

代码是这样的

#include "sys.h"
#include "led.h"
#include "delay.h"
#include "usart.h"
uint8_t cal_sum(uint8_t a, uint8_t b)
{
    return a + b;
}
uint8_t cal_sub(uint8_t a, uint8_t b)
{
    return a - b;
}
uint8_t cal_mul(uint8_t a, uint8_t b)
{
    return a * b;
}
int main(void)
{
    delay_init();
    uart_init(9600);
    printf("www.zhiguoxin.cn\r\n");
    printf("微信公众号：果果小师弟\r\n");
    uint8_t a = 10;
    uint8_t b = 8;
    /*定义一个函数指针*/
    uint8_t (*func_ptr)(uint8_t, uint8_t);
    /*将函数名赋值给函数指针*/
    func_ptr = cal_sum;
    printf("cal_sum_address  =0x%p\r\n", cal_sum);
    printf("func_ptr_address =0x%p\r\n", func_ptr);
    printf("%d + %d = %d\r\n", a, b, cal_sum(a, b));
    printf("%d + %d = %d\r\n\n", a, b, func_ptr(a, b));
    /*将函数名赋值给函数指针*/
    func_ptr = cal_sub;
    printf("cal_sub_address  =0x%p\r\n", cal_sub);
    printf("func_ptr_address =0x%p\r\n", func_ptr);
    printf("%d - %d = %d\r\n", a, b, cal_sub(a, b));
    printf("%d - %d = %d\r\n\n", a, b, func_ptr(a, b));
    /*将函数名赋值给函数指针*/
    func_ptr = cal_mul;
    printf("cal_mul_address  =0x%p\r\n", cal_mul);
    printf("func_ptr_address =0x%p\r\n", func_ptr);
    printf("%d * %d = %d\r\n", a, b, cal_mul(a, b));
    printf("%d * %d = %d\r\n", a, b, func_ptr(a, b));
    while(1)
    {
    }
}

截个图看的更清楚一点

串口打印结果：

指向函数的指针被称作是函数指针。通过函数指针，我们可以灵活的调用各种形式相同，但是功能不同的函数这样做大大的增加了代码的灵活程度。

1、typedef 函数指针

我们在定义一个函数指针时常常会这样写

uint8_t (*func_ptr)(void);

比较好理解，但是下面这个就不好理解了

typedef uint8_t (*func_ptr) (void);

是不是看着有点懵，因为一般的typedef是这样用的

typedef  原类型 别名

用法：

#include<stdio.h>
typedef unsigned       char uint8_t;
typedef unsigned short int  uint16_t;
typedef uint8_t zhiguoxin;
void main()  
{
    printf("www.zhiguoxin.cn\n");  
    printf("微信公众号：果果小师弟\n\n");      
    zhiguoxin a =10;
    printf("a=%d\n",a);    
}

使用nodepad++编译一下

然后在keil中试验

那这样是啥意思呢？

typedef uint8_t (*func_ptr) (void);

这里是把定义了一个别名叫(*func_ptr) (void) 的吗，显然不对，其含义是：

上面的例子定义func_ptr是一个函数指针, 函数类型是不带形参, 返回参数是uint8_t。

要定义的类型是uint8_t (*)(void)，没有输入参数，返回值为uint8_t 的函数指针，定义的别名是func_ptr。

在分析这种形式的定义的时候可以这样看：先去掉typedef和别名, 剩下的就是原变量的类型。去掉typedef和func_ptr以后就剩:uint8_t (*)(void)。

2.为啥使用typedef定义函数指针

答：typedef定义的函数指针类型是比较方便和明了的，因为typedef实际上就是定义一个新的数据类型，typedef有这样的一个作用，就可以用它来定义函数指针类型，这个定义的函数指针类型是能够指向返回值是uint8_t的，并且函数的参数是void类型。

这里定义的typedef uint8_t (*func_ptr) (void);;就相当于把uint8_t (*) (void); 定义成了另一个别名 func_ptr了。这个func_ptr就表示了函数指针类型。

注意：这里的uint8_t (*) (void);实际上不存在这样的写法，只是为了方便理解，这样的写法是不允许的，也是错误的！这样的写法并不代表是一个类型！

C语言真是博大精深！

3.函数指针常规定义

如果不使用typedef就应该这样定义：

#include "sys.h"
#include "led.h"
#include "delay.h"
#include "usart.h"
uint8_t cal_sum(uint8_t a, uint8_t b)
{
    return a + b;
}
int main(void)
{
    delay_init();
    uart_init(9600);
    printf("www.zhiguoxin.cn\r\n");
    printf("微信公众号：果果小师弟\r\n");
    uint8_t a = 10;
    uint8_t b = 8;
    /*定义一个函数指针*/
    uint8_t (*func_ptr)(uint8_t, uint8_t);
    /*将函数名赋值给函数指针*/
    func_ptr = cal_sum;
    printf("%d + %d = %d\r\n", a, b, func_ptr(a, b));
    while(1)
    {
    }
}

在keil中测试：

4.函数指针typedef定义

如果使用typedef就应该这样定义：

#include "sys.h"
#include "led.h"
#include "delay.h"
#include "usart.h"
uint8_t cal_sum(uint8_t a, uint8_t b)
{
    return a + b;
}
int main(void)
{
    delay_init();
    uart_init(9600);
    printf("www.zhiguoxin.cn\r\n");
    printf("微信公众号：果果小师弟\r\n");
    uint8_t a = 10;
    uint8_t b = 8;
    /*定义一个函数指针*/
    typedef  uint8_t (*func_ptr)(uint8_t, uint8_t);
    /*声明了一个函数指针变量 pFun*/
    func_ptr pFun;
    /*将这个pFun指向了cal_sum函数*/
    pFun = cal_sum;
    printf("%d + %d = %d\r\n", a, b, pFun(a, b));
    while(1)
    {
    }
}

为啥要这样？为啥要使用typedef来定义函数指针？其实这个也是类比结构体的操作，在结构体中我们也常常给结构体起别名。

综上所述：定义函数指针就有了两种方法

/* 方法1 */
uint8_t (*func_ptr)(uint8_t, uint8_t) = NULL;
/* 方法2 */
typedef  uint8_t (*func_ptr)(uint8_t, uint8_t);;
func_ptr pFun = NULL;

函数指针也有两种赋值方法：

uint8_t (*func_ptr)(uint8_t, uint8_t) = NULL;
/* 方法1 */
func_ptr= &cal_sum;
/* 方法2 */
func_ptr= cal_sum;

上面两种方法都是合法的。其实函数名就是函数的地址，你将函数名cal_sum赋值给函数指针func_ptr，与将函数的地址&cal_sum赋值给函数指针func_ptr是一样的。

同样调用函数也有两种方法：

/* 方法1 */
func_ptr(a,b)
/* 方法2 */
(*func_ptr)(a,b)

二、回调函数

既然函数指针和去普通的指针一样，普通的指针可以作为函数的形参，那么函数指针是不是也可以作为函数的形参呢？

答：是的，肯定可以。

那么函数指针作为函数的形参我们把这个函数指针叫啥呢？

答：回调函数。

回调函数原来是这样得来的啊，学到了！

能不能举一个简单的例子呢？

uint8_t compute_func(uint8_t, uint8_t);

首先我们这样写一个函数是没有问题的，但是我们现在要将函数指针作为函数的形参，这样合法吗？

uint8_t compute_func(uint8_t (*func_ptr)(uint8_t, uint8_t),uint8_t, uint8_t);

编译一下

发现没有错误也没有警告，说明我们把函数指针当做函数的形参是没有任何问题的。

在这个函数当中，通过该函数指针调用的函数被称为回调函数。这种开发方式的用途非常广泛。具体来说，在回调函数的应用场景当中，会出现两个角色。分别是某功能函数的开发者以及该功能函数的使用者。compute_func函数就是开发者写的函数，是非常牛逼的写库和底层的那一类人写的函数，我们每一个单片机的使用者，需要写出各种各样的具体的功能函数，只要我们写得功能函数的形参和返回值和函数指针的类型相同就可以了。

怎么理解？

#include "sys.h"
#include "delay.h"
#include "usart.h"
/*使用者写的函数*/
uint8_t cal_sum(uint8_t a, uint8_t b)
{
    return a + b;
}
/*开发者写的函数*/
uint8_t (compute_func)(uint8_t (*func_ptr)(uint8_t, uint8_t), uint8_t a, uint8_t b)
{
    return func_ptr(a, b);
}
int main(void)
{
    delay_init();
    uart_init(9600);
    printf("www.zhiguoxin.cn\r\n");
    printf("微信公众号：果果小师弟\r\n");
    uint8_t a = 10;
    uint8_t b = 8;
    printf("compute_func(cal_sum,a,b) =%d\r\n", compute_func(cal_sum, a, b));
    while(1)
    {
    }
}

注意：这里要注意的是我们使用者写的函数的类型一定要于开发者写的回调函数类型一样，比如形参和返回值的类型要一样。不然肯定不能调用的。

换句话说就是，下面的这两个函数的形参和返回值都必须是相同的类型才可以，不能一个有返回值一个没有，明明函数指针有两个形参，你写的函数却只有一个形参也是不行的。

正确写法：
uint8_t cal_mul(uint8_t , uint8_t )  
uint8_t (*func_ptr)(uint8_t, uint8_t)
错误写法：
void cal_mul(uint8_t , uint8_t ) //你写的函数却没有返回值
uint8_t (*func_ptr)(uint8_t, uint8_t)//函数指针有返回值
错误写法：
uint8_t  cal_mul(uint8_t) //你写的函数却只有一个形参
uint8_t (*func_ptr)(uint8_t, uint8_t)//函数指针有两个形参

我们来验证一下：

#include "sys.h"
#include "led.h"
#include "delay.h"
#include "usart.h"
/*使用者写的函数*/
uint8_t cal_sum(uint8_t a, uint8_t b)
{
    return a + b;
}
/*使用者写的函数*/
void cal_sub(uint8_t a, uint8_t b)
{
    printf("666");
}
/*使用者写的函数*/
uint8_t cal_mul( uint8_t a)
{    
    return a;
}
/*开发者写的函数*/
uint8_t (compute_func)(uint8_t (*func_ptr)(uint8_t, uint8_t), uint8_t a, uint8_t b)
{
    return func_ptr(a, b);
}
int main(void)
{
    delay_init();
    uart_init(9600);
    printf("www.zhiguoxin.cn\r\n");
    printf("微信公众号：果果小师弟\r\n");
    uint8_t a = 10;
    uint8_t b = 8;
    printf("%d\r\n", compute_func(cal_sum, a, b));
    printf("%d\r\n", compute_func(cal_sub, a, b));
    printf("%d\r\n", compute_func(cal_mul, a, b));
    while(1)
    {
    }
}

看到了在keil中编译器不会报错，但是会报警告。因为在keil中编译做了优化。那么如果我们gcc记事本编译一下会是啥样的呢？

会发现同样会有两个警告，但是还是可以运行。

如何理解回调函数

有时候会遇到这样一种情况，当上层人员将一个功能交给下层程序员完成时，上层程序员和下层程序员同步工作，这个时候该功能函数并未完成，这个时候上层程序员可以定义一个API来交给下层程序员，而上层程序员只要关心该API就可以了而无需关心具体实现，具体实现交给下层程序员完成即可(这里的上层和下层程序员不指等级关系，而是项目的分工关系)。这种情况下就会用到回调函数(Callback Function)，现在假设程序员A需要一个FFT算法，这个时候程序员A将FFT算法交给程序员B来完成，现在来让实现这个过程：

#include <stdio.h>
int  InputData[100]={0};
int OutputData[100]={0};
/*定义回调函数*/
void CallBack_FFT_Function(int *inputData,int *outputData,int num)
{
    while(num--)
    {
        printf("www.zhiguoxin.cn\r\n");
    }
}
/*用来注册回调函数的功能函数*/
void TaskA(void (*fft)(int*,int*,int))
{
    fft(InputData,OutputData,5);
}
int main(void)
{
    /*注册FFT_Function作为回调*/
    TaskA(CallBack_FFT_Function);
    return 0;
}

这个例子是不是跟上面的那个例子是相同的，只是我们在这里换了一种说法而已。也就是我们硬件层实现的某个功能，当然可以在应用层直接调用，但是这种做法太low了，一看就是小学生的水平，或者说硬件层的东西应用层根本不需要关心，这就是分层的思想。硬件的东西就给硬件工程师做，应用工程师只关心自己的需要实现的任务。这也就是驱动工程师和应用工程师的区别，我硬件工程师只需要写好对应的API函数，你应用层直接调用就好了，你不需要关心这个API函数的内部是怎么实现的。而这两者之间的桥梁就是回调函数。而回调函数的形参就是函数指针，所以本篇最开始讲的是函数指针，只要你函数指针明白了，你就会写回调函数，也就理解了这其中到底只一个什么原理。

果果小师弟

上面的代码中CallBack_FFT_Function是回调函数，该函数的形参为一个函数指针，TaskA是用来注册回调函数的功能函数。可以看到用来注册回调函数的功能函数中申明的函数指针必须和回调函数的类型完全相同。

函数指针结构体

但是很多时候我们一般在结构体中定义函数指针用的比较多一点。下面再举一个简单的例子。

#include "sys.h"
#include "led.h"
#include "delay.h"
#include "usart.h"
/****************************************
 * 函数指针结构体 开发者写的结构体
***************************************/
typedef struct
{
    uint8_t (*p_sum)(uint8_t, uint8_t);
    uint8_t (*p_sub)(uint8_t, uint8_t);
    uint8_t (*p_mul)(uint8_t, uint8_t);
    float   (*p_div)(uint8_t, uint8_t);
} Operation_T;
/*声明结构体变量g_Operation*/
Operation_T  g_Operation;
/*使用者写的回调函数*/
uint8_t cal_sum(uint8_t a, uint8_t b)
{
    return a + b;
}
/*使用者写的回调函数*/
uint8_t cal_sub(uint8_t a, uint8_t b)
{
    return a - b;
}
/*使用者写的回调函数*/
uint8_t cal_mul( uint8_t a, uint8_t b)
{
    return a * b;
}
/*使用者写的回调函数*/
float cal_div(uint8_t a, uint8_t b)
{
    return a / b;
}
/*结构体变量g_Operation初始化*/
Operation_T g_Operation = {cal_sum, cal_sub, cal_mul, cal_div};
int main(void)
{
    delay_init();
    uart_init(9600);
    printf("www.zhiguoxin.cn\r\n");
    printf("微信公众号：果果小师弟\r\n");
    uint8_t a = 10;
    uint8_t b = 8;
    /*使用函数指针调用函数*/
    printf("%d\r\n", g_Operation.p_sum(a, b));
    printf("%d\r\n", g_Operation.p_sub(a, b));
    printf("%d\r\n", g_Operation.p_mul(a, b));
    printf("%f\r\n", g_Operation.p_div(a, b));
    while(1)
    {
    }
}

三、回调在嵌入式系统中的实际使用

回调可用于多种情况，并广泛用于嵌入式固件开发。它们提供了更大的代码灵活性，并允许我们开发可由最终用户进行微调而无需更改代码的驱动程序。

在我们的代码中具有回调功能所需的元素是：

将被调用的回调函数cal_sum
将用于访问回调函数的函数指针p_sum
将调用回调函数的调用函数compute_func

在stm32的HAL库中，是使用了大量的回调函数的，串口、定时器等外设都是有对应的回调函数的，回调机制可以更好地分离代码，应用层和驱动层完全分离，降低耦合性。

简单来看几个例子，串口回调函数：

void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart);
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);

使用的时候，我们只需要把串口解析处理逻辑放在对应的回调函数中处理即可，拿串口接收来举例,定义的是一个弱函数，我们在自己的文件中重新实现就好。

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
 if (huart->Instance == USART1)
 {
  /*****Data Processing********/
 }
 else if (huart->Instance == USART2)
 {
  /*****Data Processing********/
 }
}

又比如我们在OS中的创建任务的函数就是一个用来注册回调函数的功能函数，

如果我们需要创建一个任务只需要这样写，tcp_client_socket就是我们底层开发者要写的具体的回调函数，就算你底层开发者没有把这个tcp_client_socket函数写完，对我程序的大体框架是没有任何影响的。我不管你底层开发者是否会不写，我的任务完成了。

相反我底层应用开发者只要把我底层函数写好就行了，不管写没写好，我只需要把这个tcp_client_socketAPI函数名给你就行了，其他的你也不需要管了，咋们井水不犯河水！

static void tcp_client_socket(void *thread_param)
{
    /*****Data Processing********/
}

总结

指针、结构体、函数指针、回调函数都是在嵌入式开发中非常重要的知识点，也是不好理解的，但是如果能够搞清楚它们是怎么来的，对嵌入式的进阶是非常有帮助的，所谓基础不牢，地动山摇。遇到问题一定要刨根问题。搞清楚原理，动手写代码来验证自己的思维过程，就一定能搞明白。