• C指针传参的一些思考

    一、仅操作变量名的子函数，在主函数中无法真正实现值传递

    如下：

    void swap_1(int num1, int num2) 作为主函数的子函数，被main函数调用；

    在子函数内部实现了num1 和 num2的交换（子函数中加打印可看出），但swap_1被调用后就直接释放掉了，其栈空间内存储的temp，num1，num2也同时被释放调了；因此对于main主函数中的变量a和b，并没有起到赋值的作用。

    值传递是单向的，无法通过形参（num1，num2）实现对实参（a,b）的修改。

    1. #include 
    2. void swap_1(int num1, int num2)
    3. {
    4.     int temp;
    5.     temp = num1;
    6.     num1 = num2;
    7.     num2 = temp;
    8. }
    9.  
    10. int main(int argc, const char *argv[])
    11. {
    12.     int a = 3, b = 5;
    13.     swap_1(a, b);  // 没有交换
    14.     printf("a = %d, b = %d\n", a, b);
    15.    
    16.     return 0;
    17. }
    18. /*
    19.  * result:
    20.  * a = 3, b = 5
    21.  */

    注：此处联想到1个函数实现多个返回值的操作：

    1）传入数组指针，对多个数组元素操作；（待举例）

    2）传入结构体指针，对结构体元组操作；（待举例）

    3）形参中增加指针参数，除了函数返回值外，还可以将结果通过指针返回，如下

    二、使用被调函数实现值传递的，需操作指针

    同样是子函数swap_2，通过操作传入参数的指针，交换了变量a和b的地址，实现了值（空间内容）的交换，即便swap_2被释放调，变量a和变量b的地址实际已经发生了改变。

    1. #include 
    2.  
    3. void swap_2(int *p1, int * p2)
    4. {
    5.     int temp;
    6.     temp = *p1;
    7.     *p1 = *p2;
    8.     *p2 = temp;
    9. }
    10. int main(int argc, const char *argv[])
    11. {
    12.     int a = 3, b = 5;
    13.     swap_2(&a, &b); // 交换了
    14.     printf("a = %d, b = %d\n", a, b);
    15.     return 0;
    16. }
    17. /*
    18.  * result:
    19.  * a = 5, b = 3
    20.  */

    三、通过二级指针传递一级指针的地址

    1. #include 
    2. #include 
    3. void test_1(char *p)
    4. {
    5.     p = malloc(16);//返回堆内存地址
    6.     printf("func: %s, line = %d, p = %p\n", __FUNCTION__, __LINE__, p);
    7. }
    8. void test_2(char **p)
    9. {
    10.     *p = malloc(16);//返回堆内存地址
    11.     printf("func: %s, line = %d, p = %p\n", __FUNCTION__, __LINE__, *p);
    12. }
    13. int main(int argc, const char *argv[])
    14. {
    15.     char *p1 = NULL;
    16.     char *p2 = NULL;
    17.     test_1(p1);
    18.     printf("func: %s, line = %d, p = %p\n\n", __FUNCTION__, __LINE__, p1);
    19.     test_2(&p2);
    20.     printf("func: %s, line = %d, p = %p\n", __FUNCTION__, __LINE__, p2);
    21.     return 0;
    22. }
    23. /*
    24.  * result:
    25.  *func: test_1, line = 6, p = 0x1c94260
    26.  *func: main, line = 18, p = (nil)
    28.  *func: test_2, line = 11, p = 0x1c95290
    29.  *func: main, line = 20, p = 0x1c95290
    30.  */

    四、被const修饰变量的值的修改

    一般来讲，const a 表示变量a的值不能被修改；

    但是变量a被指针p引用后，通过修改p所指向的空间内容，实现了对const 变量a的值的修改

    注：不同编译器可能会有差异 ！

    1. #include 
    2. int main( )
    3. {
    4.     int const a = 3;
    5.     int *p = (int*)&a ;
    6. 	*p = 5;
    7.     printf("a = %d,\n", a);
    8.  
    9.     return 0;
    10. }
    11.  
    12. /*
    13.  * result:
    14.  * a = 5
    15.  */

    五、数组&传参

    1、数组的地址

    int buf[10] = {0} ;

    buf：1）表示数组名，如sizeof(buf)；2）表示数组元素首地址（常量），即&buf[0]，类型是int*

    buf[0]：表示数组第一个元素，既可以作为右值被读取，也可以作为左值被写入；

    &buf[0]：等价于buf的形式二，是一个地址常量（首元素地址、数组首地址），只能作为右值；

    &buf：表示是数组首地址，是一个地址常量，只能作为右值；类型是int(*)[10]；

    1. #include 
    2.  
    3. int main()
    4. {
    5.   int buf[10] = {0} ;
    6.  
    7.   printf("%p\n",buf);
    8.   printf("%p\n",&buf);
    9.   printf("%p\n",&buf[0]);
    10.   return 0;
    11. }
    12.  
    13. 运行结果：
    14. 0x7ffefa449a30
    15. 0x7ffefa449a30
    16. 0x7ffefa449a30

    以上结果表明buf的第二种形式，与&buf 和 &buf[0]的值是一样的，都表示首地址；

    再来看另一种：

    1. #include 
    2.  
    3. int main()
    4. {
    5.   int buf[10] = {0} ;
    6.  
    7.   printf("%p\n",buf);
    8.   printf("%p\n",&buf);
    9.   printf("%p\n",&buf[0]);
    10. 	
    11.   printf("%p\n",buf+1);
    12.   printf("%p\n",&buf+1);
    13.   printf("%p\n",&buf[0]+1);
    14.   return 0;
    15. }
    16.  
    17. 运行结果：
    18. 0x7ffd0534fc40
    19. 0x7ffd0534fc40
    20. 0x7ffd0534fc40
    21. 0x7ffd0534fc44
    22. 0x7ffd0534fc68
    23. 0x7ffd0534fc44

    buf+1   表示数组首地址+1元素大小，因为buf的类型是int*

    &buf+1 表示数组首地址+1数组大小，因为&buf的类型是：int(*)[10]

    在定义数组指针时，尤其要注意这一点！

    2、访问数组的几种方式

    1）使用数组下标访问

    1.  
    2. #include 
    3.  
    4. int main()
    5. {
    6.   int buf[10] = {0,1,2,3,4,5,6,7,8,9};
    7.  
    8.   int i = 0;
    9.  
    10.   for(i = 0; i < sizeof(buf)/sizeof(buf[0]); i++)
    11.   {
    12.     printf("buf[%d] = %d\n",i,buf[i]);
    13.   }
    14.  return 0;
    15. }
    16.  
    17. 运行结果：
    18. buf[0] = 0
    19. buf[1] = 1
    20. buf[2] = 2
    21. buf[3] = 3
    22. buf[4] = 4
    23. buf[5] = 5
    24. buf[6] = 6
    25. buf[7] = 7
    26. buf[8] = 8
    27. buf[9] = 9
    28.  
    29.

    2）使用指针常量访问 *(buf+i)

    1. #include 
    2.  
    3. int main()
    4. {
    5.   int buf[10] = {0,1,2,3,4,5,6,7,8,9};
    6.  
    7.   int i = 0;
    8.  
    9.   for(i = 0; i < sizeof(buf)/sizeof(buf[0]); i++)
    10.   {
    11.     printf("buf[%d] = %d\n",i,*(buf+i));//重点：*buf是首地址常量，*(buf+1)表示第二个元素地址
    12.   }
    13.  return 0;
    14. }

    *buf是首地址常量，不能用*(buf++)，因为++只对变量操作，不能对常量进行操作

    可以用*(buf+1)表示第二个元素地址

    3）使用指针变量访问 *p = buf

    1. #include 
    2.  
    3. int main()
    4. {
    5.   int buf[10] = {0,1,2,3,4,5,6,7,8,9};
    6.  
    7.   int i = 0;
    8. 	
    9.   int *p = buf;//定义 指向数组的指针变量
    10.   // int *p;
    11.   // p = buf;也可以
    12.  
    13.   for(i = 0; i < sizeof(buf)/sizeof(buf[0]); i++)
    14.   {
    15.     printf("buf[%d] = %d\n",i,*(p++));//变量可以++操作
    16.   }
    17.  return 0;
    18. }

    由于p是指针变量，因此可以p++

    4）指针类型与数组类型的匹配

    1. int *p = null;
    2. int buf[10] = {0};
    3.  
    4. p = buf;//正确
    5. p = &buf;//错误

    因为buf 和 p的类型一致，都是int*；

    而&buf的类型是： Int(*)[10]；

    六、函数指针传参

    1、函数指针的定义

    1）一般定义

    1. #include 
    2. typedef unsigned char      uint8_t;   //1字节
    3.  
    4. uint8_t cal_sum(uint8_t a, uint8_t b)
    5. {
    6.     return a + b;
    7. }
    8.  
    9. int main(void)
    10. {
    11.     
    12.     uint8_t a = 10;
    13.     uint8_t b = 8;
    14.  
    15.     /*定义一个函数指针*/
    16.     uint8_t (*func_ptr)(uint8_t, uint8_t);
    17.     /*将函数名赋值给函数指针*/
    18.     func_ptr = cal_sum;
    19.  
    20.      printf("%d + %d = %p\r\n", a, b, func_ptr);//0x地址
    21. 	 printf("%d + %d = %d\r\n", a, b, func_ptr);//十进制地址
    22. 	 printf("%d + %d = %d\r\n", a, b, func_ptr(a,b));//函数返回值
    23.    
    24. }
    25.  
    26. 运行结果：
    27. 10 + 8 = 0x401122
    28. 10 + 8 = 4198690
    29. 10 + 8 = 18

    使用返回值时，函数指针要完整包含形参，仅有函数名时返回的仅仅是指针值（即函数地址）。

    2）使用typedef定义后声明，再赋值

    1. #include 
    2. typedef unsigned char      uint8_t;   //1字节
    3.  
    4. uint8_t cal_sum(uint8_t a, uint8_t b)
    5. {
    6.     return a + b;
    7. }
    8.  
    9. int main(void)
    10. {
    11.     
    12.     uint8_t a = 10;
    13.     uint8_t b = 8;
    14.  
    15.     /*使用typedef定义一个函数指针*/
    16. 	typedef uint8_t (*func_ptr)(uint8_t, uint8_t);
    17.      /*使用定义后的函数指针声明一个函数指针变量 pFun*/
    18.     func_ptr pFun;
    19.     /*将这个pFun指向了cal_sum函数*/
    20.     pFun = cal_sum;
    21.  
    22.      printf("%d + %d = %p\r\n", a, b, pFun);//0x地址
    23. 	 printf("%d + %d = %d\r\n", a, b, pFun);//十进制地址
    24. 	 printf("%d + %d = %d\r\n", a, b, pFun(a,b));//函数返回值
    25. 	 
    26. 	 printf("%d + %d = %p\r\n", a, b, cal_sum);//0x地址
    27. 	 printf("%d + %d = %d\r\n", a, b, cal_sum);//十进制地址
    28. 	 printf("%d + %d = %d\r\n", a, b, cal_sum(a,b));//函数返回值
    29.    
    30. }
    31.  
    32. 运行结果：
    33. 10 + 8 = 0x401122
    34. 10 + 8 = 4198690
    35. 10 + 8 = 18
    36. 10 + 8 = 0x401122
    37. 10 + 8 = 4198690
    38. 10 + 8 = 18

    使用typedef的优点在于：

    先定义一种类型的函数指针

    然后使用此函数指针声明多个同类型的函数指针变量

    再给此函数指针变量 赋值 函数（要求同类型）

    同时注意：函数指针使用时也要包含形参，不能仅用函数名或指针名，因为仅仅是一个指针

    七、结构体传参

    1、结构体指针

    顾名思义，指向结构体的指针

    1. # include 
    2. # include 
    3. struct AGE
    4. {
    5.     int year;
    6.     int month;
    7.     int day;
    8. };
    9. struct STUDENT
    10. {
    11.     char name[20];  //姓名
    12.     int num;  //学号
    13.     struct AGE birthday;  //生日
    14.     float score;  //分数
    15. };
    16. int main(void)
    17. {
    18.     struct STUDENT student1; /*用struct STUDENT结构体类型定义结构体变量student1*/
    19.     struct STUDENT *p = NULL;  /*定义一个指向struct STUDENT结构体类型的指针变量p*/
    20.     p = &student1;  /*p指向结构体变量student1的首地址, 即第一个成员的地址*/
    21.     strcpy((*p).name, "小明");  //(*p).name等价于student1.name
    22.     (*p).birthday.year = 1989;
    23.     (*p).birthday.month = 3;
    24.     (*p).birthday.day = 29;
    25.     (*p).num = 1207041;
    26.     (*p).score = 100;
    27.     printf("name : %s\n", (*p).name);  //(*p).name不能写成p
    28.     printf("birthday : %d-%d-%d\n", (*p).birthday.year, (*p).birthday.month, (*p).birthday.day);
    29.     printf("num : %d\n", (*p).num);
    30.     printf("score : %.1f\n", (*p).score);
    31.     return 0;
    32. }
    33.  
    34. 运行结果：
    35. name : 小明
    36. birthday : 1989-3-29
    37. num : 1207041
    38. score : 100.0

    我们看到，用指针引用结构体变量成员的方式是：

    (*指针变量名).成员名

    注意，*p 两边的括号不可省略，因为成员运算符“.”的优先级高于指针运算符“*”，所以如果 *p 两边的括号省略的话，那么 *p.num 就等价于 *(p.num) 了。

    从该程序也可以看出：因为指针变量 p 指向的是结构体变量 student1 第一个成员的地址，即字符数组 name 的首地址，所以 p 和 (*p).name 是等价的。

    但是，“等价”仅仅是说它们表示的是同一个内存单元的地址，但它们的类型是不同的。指针变量 p 是 struct STUDENT* 型的，而 (*p).name 是 char* 型的。所以在 strcpy 中不能将 (*p).name 改成 p。用 %s 进行输入或输出时，输入参数或输出参数也只能写成 (*p).name 而不能写成 p。

    同样，虽然 &student1 和 student1.name 表示的是同一个内存单元的地址，但它们的类型是不同的。&student1 是 struct STUDENT* 型的，而 student1.name 是 char* 型的，所以在对 p 进行初始化时，“p=&student1；”不能写成“p=student1.name”。因为 p 是 struct STUDENT* 型的，所以不能将 char* 型的 student1.name 赋给 p。

    另一种引用方式：

    指针变量名->成员名

    来代替，它们是等价的。“->”是“指向结构体成员运算符”，它的优先级同结构体成员运算符“.”一样高。p->num 的含义是：指针变量 p 所指向的结构体变量中的 num 成员。p->num 最终代表的就是 num 这个成员中的内容。

    但是要注意的是，只有“指针变量名”后面才能加“->”，千万不要在成员名如 birthday 后面加“->”。
    综上所述，以下 3 种形式是等价的：

    • 结构体变量.成员名。
    • (*指针变量).成员名。
    • 指针变量->成员名。

    其中第 3 种方式很重要，通常都是使用这种方式，另外两种方式用得不多。后面讲链表的时候用的也都是第 3 种方式。

    2、函数指针结构体

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

    1. #include 
    2. typedef unsigned char     uint8_t;
    3.  
    4.  
    5. /****************************************
    6.  * 函数指针结构体 开发者写的结构体
    7. ***************************************/
    8. typedef struct
    9. {
    10.     uint8_t (*p_sum)(uint8_t, uint8_t);
    11.     uint8_t (*p_sub)(uint8_t, uint8_t);
    12.     uint8_t (*p_mul)(uint8_t, uint8_t);
    13.     float   (*p_div)(uint8_t, uint8_t);
    14. } Operation_T;
    15.  
    16. /*声明结构体变量g_Operation*/
    17. Operation_T  g_Operation;
    18.  
    19. /*使用者写的回调函数*/
    20. uint8_t cal_sum(uint8_t a, uint8_t b)
    21. {
    22.     return a + b;
    23. }
    24. /*使用者写的回调函数*/
    25. uint8_t cal_sub(uint8_t a, uint8_t b)
    26. {
    27.     return a - b;
    28.  
    29. }
    30. /*使用者写的回调函数*/
    31. uint8_t cal_mul( uint8_t a, uint8_t b)
    32. {
    33.     return a * b;
    34.  
    35. }
    36. /*使用者写的回调函数*/
    37. float cal_div(uint8_t a, uint8_t b)
    38. {
    39.     return a / b;
    40.  
    41. }
    42. /*结构体变量g_Operation初始化*/
    43. Operation_T g_Operation = {cal_sum, cal_sub, cal_mul, cal_div};
    44.  
    45. int main(void)
    46. {
    47.     uint8_t a = 10;
    48.     uint8_t b = 8;
    49.     /*使用函数指针调用函数*/
    50.     printf("%d\r\n", g_Operation.p_sum(a, b));
    51.     printf("%d\r\n", g_Operation.p_sub(a, b));
    52.     printf("%d\r\n", g_Operation.p_mul(a, b));
    53.     printf("%f\r\n", g_Operation.p_div(a, b));
    54. }
    55.  
    56.  
    57. 运行结果：
    58. 18
    59. 2
    60. 80
    61. 1.000000

    3、指向结构体数组的指针

    1. # include 
    2. struct STU
    3. {
    4.     char name[20];
    5.     int age;
    6.     char sex;
    7.     char num[20];
    8. };
    9. int main(void)
    10. {
    11.     struct STU stu[3] = {{"小红", 22, 'F', "Z1207031"}, {"小明", 21, 'M', "Z1207035"}, {"小七", 23, 'F', "Z1207022"}};
    12.     struct STU *p = stu;
    13.     for (; p3; ++p)
    14.     {
    15.         printf("name:%s; age:%d; sex:%c; num:%s\n", p->name, p->age, p->sex, p->num);
    16.     }
    17.     return 0;
    18. }
    19.  
    20. 运行结果：
    21. name:小红; age:22; sex:F; num:Z1207031
    22. name:小明; age:21; sex:M; num:Z1207035
    23. name:小七; age:23; sex:F; num:Z1207022

    此时指针变量 p 就指向了结构体数组的第一个元素，即指向 stu[0]。我们知道，当一个指针指向一个数组后，指针就可以通过移动的方式指向数组的其他元素。
    这个原则对结构体数组和结构体指针同样适用，

    所以 p+1 就指向 stu[1] 的首地址；p+2 就指向 stu[2] 的首地址……所以只要利用 for 循环，指针就能一个个地指向结构体数组元素。
    同样需要注意的是，要将一个结构体数组名赋给一个结构体指针变量，那么它们的结构体类型必须相同。

    此外同前面“普通数组和指针的关系”一样，当指针变量 p 指向 stu[0] 时，p[0] 就等价于 stu[0]；p[1] 就等价于 stu[1]；p[2] 就等价于 stu[2]……所以 stu[0].num 就可以写成 p[0].num，其他同理。下面将上面的程序用 p[i] 的方式修改一下：

    1. # include 
    2. struct STU
    3. {
    4.     char name[20];
    5.     int age;
    6.     char sex;
    7.     char num[20];
    8. };
    9. int main(void)
    10. {
    11.     struct STU stu[3] = {{"小红", 22, 'F', "Z1207031"}, {"小明", 21, 'M', "Z1207035"}, {"小七", 23, 'F', "Z1207022"}};
    12.     struct STU *p = stu;
    13.     int i = 0;
    14.     for (; i<3; ++i)
    15.     {
    16.         printf("name:%s; age:%d; sex:%c; num:%s\n", p[i].name, p[i].age, p[i].sex, p[i].num);
    17.     }
    18.     return 0;
    19. }

    4、指向“函数指针结构体”的指针

    待补充

    八、回调函数

    1、定义

    回调函数就是一个被作为参数传递的函数；

    回调函数是一个通过函数指针方式，被调用的函数；

    函数指针作为函数的形参我们把这个函数指针称为“回调函数”

    1.回调函数是一个函数指针

    2.回调函数是一个作为其他函数形参的函数指针

    3.回调函数即包含返回值，也包含形参；也可能是多个函数指针的嵌套

    4.把一段可执行的代码像参数传递那样传给其他代码，如果这段代码被立即执行称为“同步回调”，如果之后再执行称为“异步回调”。

    5.回调函数不是由实现方调用，而是在特定条件下，由另一方调用。

    6.例如，同一功能函数，通过函数指针调用不同的回调函数，达到实现不同的功能目的。

    1. /*具有返回值和两个形参的一个函数*/
    2. uint8_t compute_func1(uint8_t, uint8_t);
    3.  
    4. /*常规定义一个函数指针*/
    5. uint8_t (*func_ptr)(uint8_t, uint8_t);
    6.  
    7. /*将函数名赋值给函数指针，两者必须同类型*/
    8. func_ptr = compute_func1
    9.  
    10. /*包含回调函数“uint8_t (*func_ptr)(uint8_t, uint8_t)”作为形参的一个功能函数compute_func2  */
    11.  
    12. uint8_t compute_func2(uint8_t (*func_ptr)(uint8_t, uint8_t),uint8_t, uint8_t);

    在这个函数当中，通过该函数指针调用的函数被称为回调函数

    回调函数：uint8_t compute_func(uint8_t, uint8_t) 

    功能函数：uint8_t compute_func2(uint8_t, uint8_t) 

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

    1. #include 
    2. typedef unsigned char      uint8_t;   //1字节
    3.  
    4. /*使用者写的函数*/
    5. uint8_t cal_sum(uint8_t a, uint8_t b)
    6. {
    7.     return a + b;
    8. }
    9. /*开发者写的函数*/
    10. uint8_t (compute_func)(uint8_t (*func_ptr)(uint8_t, uint8_t), uint8_t a, uint8_t b)
    11. {
    12.     return func_ptr(a, b);
    13. }
    14. int main(void)
    15. {
    16.     
    17.     uint8_t a = 10;
    18.     uint8_t b = 8;
    19.  
    20. 	printf("compute_func(cal_sum,a,b) =%d\r\n", compute_func(cal_sum, a, b));
    21. 	printf("compute_func地址 =%p\r\n", compute_func);
    22. }
    23.  
    24. 运行结果：
    25. compute_func(cal_sum,a,b) =18
    26. compute_func地址 =0x40113c

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

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

    1. //正确写法：
    2. uint8_t cal_mul(uint8_t , uint8_t ) 
    3. uint8_t (*func_ptr)(uint8_t, uint8_t)
    4.  
    5. //错误写法：
    6. void cal_mul(uint8_t , uint8_t ) //你写的函数却没有返回值
    7. uint8_t (*func_ptr)(uint8_t, uint8_t)//函数指针有返回值
    8.  
    9. //错误写法：
    10. uint8_t  cal_mul(uint8_t) //你写的函数却只有一个形参
    11. uint8_t (*func_ptr)(uint8_t, uint8_t)//函数指针有两个形参

    2、回调函数的注册和使用

    1. #include 
    2.  
    3. int  InputData[100]={0};
    4. int OutputData[100]={0};
    5.  
    6. /*定义回调函数*/
    7. void CallBack_FFT_Function(int *inputData,int *outputData,int num)
    8. {
    9.     while(num--)
    10.     {
    11.         printf("国内疫情结束，再也不用做核酸了！\r\n");
    12.     }
    13. }
    14. /*用来注册回调函数的功能函数*/
    15. void TaskA(void (*fft)(int*,int*,int))
    16. {
    17.     fft(InputData,OutputData,5);
    18. }
    19.  
    20. int main(void)
    21. {
    22.     /*注册FFT_Function作为回调*/
    23.     TaskA(CallBack_FFT_Function);
    24.     return 0;
    25. }

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

    3、回调函数在嵌入式中的具体实例

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

    • 将被调用的回调函数cal_sum

    • 将用于访问回调函数的函数指针p_sum

    • 将调用回调函数的调用函数compute_func

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

    1. void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart);//串口发送完成回调
    2. void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart);//串口接收完成回调

    串口中断发送/接收完成之后，会进入该函数，该函数为空函数，用户需自行修改。

  • 相关阅读:
    集成环信IM时常见问题及解决——包括消息、群组、推送
    python 之爬虫基础（2）
    华为、小米OV折叠屏市场再厮杀
    [Codeforces] number theory (R1200) Part.7
    提升吃鸡战斗力，分享顶级作战干货！
    OA系统开发
    Go-Python-Java-C-LeetCode高分解法-第八周合集
    Feign踩坑源码分析--@FeignClient注入容器
    【Cherno的C++视频】Stacks vs heap in C++
    谷粒商城 高级篇 (八) --------- 缓存使用
  • 原文地址：https://blog.csdn.net/pl0020/article/details/127779774