• 【C语言】指针的进阶（二）—— 回调函数的讲解以及qsort函数的使用方式

    目录

    1、函数指针数组

    1.1、函数指针数组是什么？

     1.2、函数指针数组的用途：转移表

    2、扩展：指向函数指针的数组的指针

    3、回调函数

    3.1、回调函数介绍

     3.2、回调函数的案例：qsort函数

    3.2.1、回顾冒泡排序

     3.2.1、什么是qsort函数？

    1、函数指针数组

    1.1、函数指针数组是什么？

    函数指针数组是什么？首先主语是数组，数组是一个存放相同类型数据的存储空间。那我们已经学习了指针数组，比如：

    char* arr[5]  ———— 字符指针数组，它是一个数组，存放的是字符指针。

    int* arr[5]     ———— 整型指针数组，它是一个数组，存放的是整型指针。

    假设有这么一个使用场景，我需要将几个函数的地址存放到一个数组中，那应该怎么存？下面给大家介绍一下：函数指针数组

    1. int Add(int x, int y)
    2. {
    3. 	return x + y;
    4. }
    5.  
    6. int Sub(int x, int y)
    7. {
    8. 	return x - y;
    9. }
    10.  
    11. int main()
    12. {
    13. 	int (*pf1)(int, int) = &Add;  //pf1和pf2是函数指针
    14. 	int (*pf2)(int, int) = ⋐
    15. 	//数组中存放类型相同的多个数组
    16. 	int (*pfArr[4])(int, int) = { &Add,&Sub };  //pfArr就是函数指针数组
    17.  
    18. 	return 0;
    19. }

    函数指针数组的写法与函数指针非常相似，只需要在名字后加个方括号[ ]就可以了。

    注意：因为数组是一个存放相同类型数据的存储空间，所以函数指针数组只能够存放返回类型和参数类型都一致的函数的函数地址。

     1.2、函数指针数组的用途：转移表

    用C语言实现一个计算器功能（加减乘除）：

    1. int add(int a, int b)
    2. {
    3. 	return a + b;
    4. }
    5. int sub(int a, int b)
    6. {
    7. 	return a - b;
    8. }
    9. int mul(int a, int b)
    10. {
    11. 	return a * b;
    12. }
    13. int div(int a, int b)
    14. {
    15. 	return a / b;
    16. }
    17.  
    18. void menu()
    19. {
    20. 	printf("*******************************\n");
    21. 	printf("******   1.add   2.sub    *****\n");
    22. 	printf("******   3.mul   4.div    *****\n");
    23. 	printf("******   0.exit           *****\n");
    24. 	printf("*******************************\n");
    25. }
    26.  
    27. int main()
    28. {
    29. 	int input = 0;
    30. 	int a = 0;
    31. 	int b = 0;
    32. 	int ret = 0;
    33. 	do
    34. 	{
    35. 		menu();
    36. 		printf("请选择:>");
    37. 		scanf("%d", &input);
    38. 		switch (input)
    39. 		{
    40. 		case 1:
    41. 			printf("请输入2个操作数:");
    42. 			scanf("%d %d", &a, &b);
    43. 			ret = add(a, b);
    44. 			printf("%d\n", ret);
    45. 			break;
    46. 		case 2:
    47. 			printf("请输入2个操作数:");
    48. 			scanf("%d %d", &a, &b);
    49. 			ret = sub(a, b);
    50. 			printf("%d\n", ret);
    51. 			break;
    52. 		case 3:
    53. 			printf("请输入2个操作数:");
    54. 			scanf("%d %d", &a, &b);
    55. 			ret = mul(a, b);
    56. 			printf("%d\n", ret);
    57. 			break;
    58. 		case 4:
    59. 			printf("请输入2个操作数:");
    60. 			scanf("%d %d", &a, &b);
    61. 			ret = div(a, b);
    62. 			printf("%d\n", ret);
    63. 			break;
    64. 		case 0:
    65. 			printf("退出计算器\n");
    66. 			break;
    67. 		default:
    68. 			printf("选择错误，重新选择\n");
    69. 			break;
    70. 		}
    71. 	} while (input);
    72. 	return 0;
    73. }

        上面的代码虽然能实现一个计算器功能，但是可以发现，这个代码特别地冗余，重复的部分非常多，并且如果需要添加多一个功能是，又需要再添加多一个case，导致代码越来越长，重复部分也越来越多，这是非常不好的代码习惯，那有什么办法能够解决呢？

        其实我们通过观察可以发现，这些函数有一些特点，就是除了函数名不同之外，返回类型以及参数类型都是一致的。

        既然除了函数名不同之外其余都相同，那么是否就可以使用函数指针数组来改造一下代码？

    1. int add(int a, int b)
    2. {
    3. 	return a + b;
    4. }
    5. int sub(int a, int b)
    6. {
    7. 	return a - b;
    8. }
    9. int mul(int a, int b)
    10. {
    11. 	return a * b;
    12. }
    13. int div(int a, int b)
    14. {
    15. 	return a / b;
    16. }
    17.  
    18. void menu()
    19. {
    20. 	printf("*******************************\n");
    21. 	printf("******   1.add   2.sub    *****\n");
    22. 	printf("******   3.mul   4.div    *****\n");
    23. 	printf("******   0.exit           *****\n");
    24. 	printf("*******************************\n");
    25. }
    26.  
    27. int main()
    28. {
    29. 	int input = 0;
    30. 	int a = 0;
    31. 	int b = 0;
    32. 	int ret = 0;
    33. 	do
    34. 	{
    35. 		menu();
    36. 		printf("请选择:>");
    37. 		scanf("%d", &input);
    38. 		//创建一个函数指针数组
    39. 		int (*pfArr[])(int, int) = { NULL,add,sub,mul,div };
    40. 						    //为了使数组下标与菜单序号对应起来，在0下标处放置一个NULL
    41. 		if (input == 0)
    42. 		{
    43. 			printf("退出计算器\n");
    44. 		}
    45. 		else if (input >= 1 && input <= 4)
    46. 		{
    47. 			printf("请输入2个操作数:");
    48. 			scanf("%d %d", &a, &b);
    49. 			ret = pfArr[input](a, b); //下标访问数组中的函数并调用
    50. 			printf("ret = %d\n", ret);
    51. 		}
    52. 		else
    53. 		{
    54. 			printf("选择错误，重新选择\n");
    55. 		}
    56. 	} while (input);
    57. 	return 0;
    58. }

    可以看到，使用函数指针数组一样可以完成。未来如果还需要添加其他功能时，只需要在菜单发生变化，然后写出实现功能的函数，再将函数放入函数指针数组当中就可以了。而我们把这种场景下使用的函数指针数组就叫做转移表。

    这也就是说：使用函数指针数组不仅大大提高了代码的质量，而且大大降低了维护成本。

    2、扩展：指向函数指针的数组的指针

    指向函数指针数组的指针是一个指针，指针指向一个数组 ，数组的元素都是函数指针 。

    如何定义？

    1. void test(const char* str)
    2. {
    3. 	printf("%s\n", str);
    4. }
    5. int main()
    6. {
    7. 	//函数指针pfun
    8. 	void (*pfun)(const char*) = test;
    9. 	//函数指针的数组pfunArr
    10. 	void (*pfunArr[5])(const char* str);
    11. 	pfunArr[0] = test;
    12. 	//指向函数指针数组pfunArr的指针ppfunArr
    13. 	void (*(*ppfunArr)[5])(const char*) = &pfunArr;
    14. 	return 0;
    15. }

    void (*(*ppfunArr)[5])(const char*)

    void (*(*ppfunArr)[5])(const char*)，ppfunArr首先与*结合，所以它是一个指针。

    void (*(*ppfunArr)[5])(const char*)，再和[5]结合，表示指针指向一个大小为5的数组，每个数组存放的类型是函数指针void (*)(const char*)。

    当然这里讲到的函数指针数组指针已经是很深入的内容了，使用场景非常少，只作为扩展了解即可，看不懂也不需要太过于担心。

     

    3、回调函数

    3.1、回调函数介绍

    回调函数在C语言中的地位非常高，非常重要。回调函数是依赖函数指针的，有了函数指针才能实现回调函数。在前面计算器功能使用函数指针数组调用加减乘除函数的时候，加减乘除函数就被成为回调函数。

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

     再次用计算器功能作为例子讲解：

    观察代码可以发现 ，只有调用函数部分不一样，那么能不能定义一个cacl()函数，通过将加减乘除函数作为参数传入到calc函数中，达到在calc函数中调用加减乘除函数？

    按照这个思路修改后的代码：

    1. int add(int a, int b)
    2. {
    3. 	return a + b;
    4. }
    5. int sub(int a, int b)
    6. {
    7. 	return a - b;
    8. }
    9. int mul(int a, int b)
    10. {
    11. 	return a * b;
    12. }
    13. int div(int a, int b)
    14. {
    15. 	return a / b;
    16. }
    17.  
    18. void menu()
    19. {
    20. 	printf("*******************************\n");
    21. 	printf("******   1.add   2.sub    *****\n");
    22. 	printf("******   3.mul   4.div    *****\n");
    23. 	printf("******   0.exit           *****\n");
    24. 	printf("*******************************\n");
    25. }
    26.  
    27. void calc(int(*pf)(int, int))
    28. {
    29. 	int a = 0;
    30. 	int b = 0;
    31. 	int ret = 0;
    32. 	printf("请输入2个操作数:");
    33. 	scanf("%d %d", &a, &b);
    34. 	ret = pf(a, b);
    35. 	printf("%d\n", ret);
    36. }
    37.  
    38. int main()
    39. {
    40. 	int input = 0;
    41. 	do
    42. 	{
    43. 		menu();
    44. 		printf("请选择:>");
    45. 		scanf("%d", &input);
    46. 		switch (input)
    47. 		{
    48. 		case 1:
    49. 			calc(add);
    50. 			break;
    51. 		case 2:
    52. 			calc(sub);
    53. 			break;
    54. 		case 3:
    55. 			calc(mul);
    56. 			break;
    57. 		case 4:
    58. 			calc(div);
    59. 			break;
    60. 		case 0:
    61. 			printf("退出计算器\n");
    62. 			break;
    63. 		default:
    64. 			printf("选择错误，重新选择\n");
    65. 			break;
    66. 		}
    67. 	} while (input);
    68. 	return 0;
    69. }

    【图解】

    可以把calc函数理解为中转站，给我参数传递什么函数地址，我就调用什么函数。

    提示：在往期博客中我有得出过一个结论：函数指针在调用所指向函数时，可以不写*直接和函数名一样调用函数，而*号在这里其实就只是一个摆设，同样是为了照顾初学者的使用习惯，所以才会导致当加了很多*号去解引用时得出来的结果依然是正确的结果。

    即(*pf)(a,b)等价于pf(a,b)。

    如果想要了解更透彻，可以前往我的往期博客阅读函数指针部分。（链接：点击前往）

     3.2、回调函数的案例：qsort函数

    3.2.1、回顾冒泡排序

     为了方便对比，我们先复习一下冒泡排序：

    1. //冒泡排序算法
    2. //给一组整型数据，然后使用冒泡排序对数据进行升序排序。
    3.  
    4. void bubble_sort(int arr[], int sz)
    5. {
    6. 	//趟数
    7. 	int i = 0;
    8. 	for ( i = 0; i < sz - 1; i++)
    9. 	{
    10. 		//每一趟冒泡排序的过程
    11. 		int j = 0;
    12. 		for ( j = 0; j < sz - 1 - i; j++)
    13. 		{
    14. 			if (arr[j] > arr[j + 1])
    15. 			{
    16. 				int tmp = arr[j];
    17. 				arr[j] = arr[j + 1];
    18. 				arr[j + 1] = tmp;
    19. 			}
    20. 		}
    21. 	}
    22. }
    23.  
    24. int main()
    25. {
    26. 	int arr[] = { 10,9,8,7,6,5,4,3,2,1 };
    27. 	int sz = sizeof(arr) / sizeof(arr[0]);
    28. 	bubble_sort(arr, sz);
    29. 	int i = 0;
    30. 	for ( i = 0; i < sz; i++)
    31. 	{
    32. 		printf("%d ", arr[i]);
    33. 	}
    34. 	return 0;
    35. }

    上面就是冒泡排序的实现，但是可以看到，这个冒泡排序其实是有缺陷的，它的参数是int类型，限制了它只能够排序整型数据！而这里即将讲到的qsort函数就是一个可以用来排序任意类型数据的函数。

     3.2.1、什么是qsort函数？

    qsort是一个库函数，底层使用的是快速排序的方式对数据进行排序。头文件：

    这个函数可以直接使用用来排序任意类型的数据。

    当然除了快速排序，还有很多排序，例如：冒泡排序、选择排序，希尔排序，归并排序等等

    qsort函数定义原型：

    void qsort (void* base, size_t num, size_t size, int (*compar)(const void*,const void*));

    • void* base：待排序数组的第一个元素的地址
    • size_t num：待排序数组的元素个数
    • size_t size：以字节为单位，待排序数组中一个元素的大小。
    • int (*compar)(const void*,const void*)：函数指针，指向一个函数，用来比较两个元素，由用户自行创建并封装。

     比较函数的形参中为什么用的是void*：

    void* 是无具体类型的指针，不能进行解引用操作符，也不能进行+-整数的操作，它是用来存放任意类型数据的地址（可以理解为垃圾桶，什么都能装，当需要用时再强制类型转换为需要的类型）。只有void*被允许存放任意类型数据的地址，如果是其他类型的指针编译器会报错。正是因为定义qsort函数时用的是void*，qsort函数才可以排序任意类型的数据。

    使用qsort函数最重要的就是最后一个参数，这个参数决定了qsort函数比较两个元素的规则。这里先写一个用于排序整型数据的比较函数cmp_int：

    1. int cmp_int(const void* e1, const void* e2)
    2. {
    3. 	return *(int*)e1 - *(int*)e2;
    4. }

     比较函数的要求：

    • 当p1指向的元素大于p2指向的元素时，返回大于0的数
    • 当p1指向的元素等于p2指向的元素时，返回0
    • 当p1指向的元素小于p2指向的元素时，返回小于0的数

     【完整代码】

     使用qsort函数排序整型数据。

    1. int cmp_int(const void* e1, const void* e2)
    2. {
    3. 	return *(int*)e1 - *(int*)e2;
    4. }
    5.  
    6. int main()
    7. {
    8. 	int arr[] = { 10,9,8,7,6,5,4,3,2,1 };
    9. 	int sz = sizeof(arr) / sizeof(arr[0]);
    10. 	qsort(arr, sz, sizeof(arr[0]), cmp_int);
    11. 	int i = 0;
    12. 	for ( i = 0; i < sz; i++)
    13. 	{
    14. 		printf("%d ", arr[i]);
    15. 	}
    16. 	return 0;
    17. }

    同理，qsort函数排序结构体类型数据（下面例子以结构体中的年龄来排序）：

    1. struct Stu
    2. {
    3. 	char name[20];
    4. 	int age;
    5. };
    6.  
    7. int cmp_struct(const void* e1, const void* e2)
    8. {
    9. 	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
    10. }
    11.  
    12. int main()
    13. {
    14. 	struct Stu arr[] = { {"zhangsan",20},{"lisi",21},{"wangwu",22} };
    15. 	int sz = sizeof(arr) / sizeof(arr[0]);
    16. 	qsort(arr, sz, sizeof(arr[0]), cmp_struct);
    17. 	return 0;
    18. }

     【运行结果】

    可以发现确实是完成了按年龄排序。

    如果觉得作者写的不错，求给博主一个大大的点赞支持一下，你们的支持是我更新的最大动力！

    如果觉得作者写的不错，求给博主一个大大的点赞支持一下，你们的支持是我更新的最大动力！

    如果觉得作者写的不错，求给博主一个大大的点赞支持一下，你们的支持是我更新的最大动力！

  • 相关阅读:
    抖音矩阵系统定制开发，抖音矩阵系统源码独立部署、
    设信号x(t)=cos(2π×50t)+2×cos(2π×400t)，试将它的两个频率分量分离，并绘制它们的时域波形及频谱图
    单例模式 饿汉式和懒汉式的区别
    重新认识Word —— 制作简历
    UUID转16字节数组（Java）
    IDEA下载与安装，保姆级教程
    ajax：实现前端向后端发请求接收数据的过程、前后端交互
    什么是营销自动化工具？简单的营销自动化流程如何设计？
    IntelliJ IDEA 下.properties 中文乱码问题
    【微服务】Gateway的基本配置详解
  • 原文地址：https://blog.csdn.net/zzzzzhxxx/article/details/132941465