这样写大家应该很熟悉吧，我首先定义了一个函数指针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`是用来注册回调函数的功能函数。可以看到**用来注册回调函数的功能函数中申明的函数指针必须和回调函数的类型完全相同**。
**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上物联网嵌入式知识点，真正体系化！**
**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、电子书籍、讲解视频，并且后续会持续更新**
**[如果你需要这些资料，可以戳这里获取](https://gitee.com/vip204888)**
