C语言程序设计笔记---017
C语言进阶之回调函数
前言：
通过C语言进阶前篇的指针进阶01的知识，继续学习。这篇引用一个简易计算器的程序进行深入学习指针进阶的知识。
/知识点汇总/
1、函数指针数组
比如：指针数组
char* arr[5];//字符指针数组 --- 数组 -- 存放的是字符指针
int* arr2[5];//整型指针数组 -- 数组 -- 存放的是整型指针
那么函数指针数组 – 是数组 – 存放的是函数指针 – 函数指针变量存放的是函数的地址
引入简易计算器程序理解分析：
#include <stdio.h>
int Add(int x, int y)
{
return x + y;
}
int Sub(int x, int y)
{
return x - y;
}
int Mul(int x, int y)
{
return x * y;
}
int Div(int x, int y)
{
return x / y;
}
void menu()
{
printf("**************************\n");
printf("****** 1. Add 2.Sub ******\n");
printf("****** 3. Mul 4.Div ******\n");
printf("****** 0.exit ******\n");
printf("**************************\n");
}
int main()
{
int input = 0;
int x = 0;
int y = 0;
int ret = 0;
do
{
menu();
printf("请选择:>");
scanf("%d", &input);
switch (input)
{
case 1:
printf("请输入2个操作数：");
scanf("%d %d", &x, &y);
ret = Add(x, y);
printf("ret = %d\n", ret);
break;
case 2:
printf("请输入2个操作数：");
scanf("%d %d", &x, &y);
ret = Sub(x, y);
printf("ret = %d\n", ret);
break;
case 3:
printf("请输入2个操作数：");
scanf("%d %d", &x, &y);
ret = Mul(x, y);
printf("ret = %d\n", ret);
break;
case 4:
printf("请输入2个操作数：");
scanf("%d %d", &x, &y);
ret = Div(x, y);
printf("ret = %d\n", ret);
break;
case 0:
printf("退出程序\n");
break;
default:
printf("输入错误，请重新输入\n");
break;
}
} while (input);
return 0;
}
发现上面的代码，较冗余，可扩展性差；又发现各个函数除了函数名与函数体不同，函数参数类型，和返回值类型均相同
所以引入函数指针数组的引用对代码进行优化：
(前提是函数参数类型，和返回值类型均相同)
#include <stdio.h>
int Add(int x, int y)
{
return x + y;
}
int Sub(int x, int y)
{
return x - y;
}
int Mul(int x, int y)
{
return x * y;
}
int Div(int x, int y)
{
return x / y;
}
void menu()
{
printf("**************************\n");
printf("****** 1. Add 2.Sub ******\n");
printf("****** 3. Mul 4.Div ******\n");
printf("****** 0.exit ******\n");
printf("**************************\n");
}
int main()
{
int input = 0;
int x = 0;
int y = 0;
int ret = 0;
do
{
menu();
printf("请选择:>");
scanf("%d", &input);
//函数指针数组
//int (*pfarr[4])(int, int) = { Add,Sub,Mul,Div };
//数字下标不对应： 0 1 2 3
//优化让其与菜单对齐：
int (*pfarr[5])(int, int) = {
NULL,Add,Sub,Mul,Div };
if (0 == input)
printf("退出程序\n");
else if (input >= 1 && input <= 4)
{
printf("请输入两个操作数：");
scanf("%d %d", &x, &y);
ret = pfarr[input](x, y);
printf("ret = %d\n", ret);
}
else
printf("输入错误，请重新输入\n");
} while (input);
return 0;
}
但是此时的代码还是显得有些复杂，那么继续深入，引用回调函数？
2、回调函数
概念：
(1)、回调函数就是一个通过函数指针调用的函数。
(2)、如果你把函数的指针(地址)作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这个是回调函数。
(3)、回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外一方调用的，用于对该事件或条件进行响应。
然后接着上面的引子。继续优化建议计算器的代码，引入回调函数思想：
#include <stdio.h>
int Add(int x, int y)
{
return x + y;
}
int Sub(int x, int y)
{
return x - y;
}
int Mul(int x, int y)
{
return x * y;
}
int Div(int x, int y)
{
return x / y;
}
//回调函数
void calc(int (*p)(int, int))
{
int x = 0;
int y = 0;
int ret = 0;
printf("请输入2个操作数：");
scanf("%d %d", &x, &y);
ret = p(x, y);
printf("ret = %d\n", ret);
}
void menu()
{
printf("**************************\n");
printf("****** 1. Add 2.Sub ******\n");
printf("****** 3. Mul 4.Div ******\n");
printf("****** 0.exit ******\n");
printf("**************************\n");
}
int main()
{
int input = 0;
int x = 0;
int y = 0;
int ret = 0;
do
{
menu();
printf("请选择:>");
scanf("%d", &input);
switch (input)
{
case 1:
calc(Add);
break;
case 2:
calc(Sub);
break;
case 3:
calc(Mul);
break;
case 4:
calc(Div);
break;
case 0:
printf("退出程序\n");
break;
default:
printf("输入错误，请重新输入\n");
break;
}
} while (input);
return 0;
}
3、 回调函数的应用 — qsort库函数
qosrt函数的介绍：底层使用的快速排序的方式，是实现对数据进行排序的；可直接调用qsort库函数，并且可用来对排序任意类型的数据.
//对数据的排序有很多种方法：
//冒泡排序
//选择排序
//插入排序
//快速排序
//…
//那么qsort函数具体怎么使用呢？
这里引用经典的冒泡排序来学习，首先回顾冒泡排序的思想：两两相邻的元素进行比较排序
#include <stdio.h>
void bubble_sort(int* arr, int sz)
{
int i = 0;
int j = 0;
//趟数 -- 趟数等于sz - 1,比如10个元素只需要执行9趟
for (i = 0; i < sz - 1; i++)
{
for (j = 0; j < sz - 1 - i; j++)//剩余比较的对数
{
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
void print(int* arr, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
}
int main()
{
//数据
int arr[] = {
9,8,7,6,5,4,3,2,1,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
print(arr, sz);
bubble_sort(arr, sz);//冒泡排序
print(arr, sz);
return 0;
}
通过冒泡排序得知，只局限于排序整型的数据；那么如果我想排序浮点数或者字符串呢？
所以引出qsort库函数，来兼容任意类型的排序，这里以结构体类型为例。
qsort函数
原型：void qsort( void *base, size_t num, size_t width, int (__cdecl *compare )(const void *elem1, const void elem2 ) );
头文件：<stdlib.h>
//参数1：base 待排序数组的起始地址
//参数2：num待排序数组元素的个数
//参数3：待排序数组元素类型的大小，单位字节,sizeof(arr[0])
//参数4：是一个函数指针类型,compare指向了一个函数，该函数的参数类型是void任意类型的数据，返回值类型是函数指针类型，其次compare该函数实现的功能是比较相邻元素e1、e2的大小，e1和e2中存放的是需要比较的两个元素的地址。
补充：
void* 指针类型的作用：
void* 类型的指针，是无具体类型的指针，本质是方便用来存放任意类型的地址，和转换需要类型的功能
所以qsort函数的思想运用了回调函数的思想：
因为void类型与我们此时需要比较的数组元素类型不同，则需要用强制类型转换,使得数据类型达成一致
其次，void 类型的指针 – 不能进行解引用操作符，也不能进行±整数的操作，所以也证明了想要取数组的元素地址，需要使用强制类型转换。
compar函数的比较含义：
1.排序整形数组时，两个整型可直接使用>比较
2.排序结构体数组时，两个结构体的数据不能直接使用>比较，也就是不同类型的数据比较方式，也会不同。
该compar函数的返回值类型规定：
当e1指向的元素 > e2指向的元素时，返回一个大于0的数字
当e1指向的元素 = e2指向的元素时，返回一个等于0的数字
当e1指向的元素 < e2指向的元素时，返回一个小于0的数字
简述：cmp_int()功能就是写比较两个被指向的元素大小即可
#include <stdio.h>
#include <stdlib.h> //调用qsort函数需声明的头文件
#include <string.h> //调用strcmp函数需声明的头文件
void print(int* arr, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
}
//因为void*类型与我们此时需要比较的数组元素类型不同，则需要用强制类型转换,使得数据类型达成一致
//其次，void* 类型的指针 -- 不能进行解引用操作符，也不能进行+-整数的操作，所以也证明了想要取数组的元素地址，需要使用强制类型转换
int cmp_int(const void* e1,const void* e2)
{
return *(int*)e1 - *(int*)e2;
}
//该函数的返回值类型规定：
//当e1指向的元素 > e2指向的元素时，返回一个大于0的数字
//当e1指向的元素 = e2指向的元素时，返回一个等于0的数字
//当e1指向的元素 < e2指向的元素时，返回一个小于0的数字
//简述：cmp_int()功能就是写比较两个被指向的元素大小即可
void test1()
{
int arr[] = {
9,8,7,6,5,4,3,2,1,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
print(arr, sz);
qsort(arr,sz,sizeof(arr[0]),cmp_int);//快速排序
print(arr, sz);
}
//定义结构体类型
struct Stu
{
char name[20];
int age;
};
//结构体数据该如何比较排序呢？根据结构体参数来看：
//1.根据年龄比较
//2.根据名字比较
int cmp_stu_by_age(const void* e1, const void* e2)
{
return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
int cmp_stu_by_name(const void* e1, const void* e2)
{
return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
void print_struct(struct Stu* arr,int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("name = %s ,age = %d\n", arr[i].name, arr[i].age);
}
printf("\n");
}
void test2()
{
struct Stu arr[3] = {
{
"zhangsan",20},{
"lisi",30},{
"wangwu",12} };
int sz = sizeof(arr) / sizeof(arr[0]);
print_struct(arr, sz);
qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);//快速排序
print_struct(arr, sz);
}
void test3()
{
struct Stu arr[3] = {
{
"zhangsan",20},{
"lisi",30},{
"wangwu",12} };
int sz = sizeof(arr) / sizeof(arr[0]);
print_struct(arr, sz);
qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);//快速排序
print_struct(arr, sz);
}
int main()
{
//test1();//排序整型数据
//test2();//排序结构体数据类型 -- 以年龄age排序
test3();//排序结构体数据类型 -- 以姓名name排序
return 0;
}
小结：
使用qsort我们需要明白其参数的含义，根据需要排序的数据类型进行，填参数并且重要的是用户根据需要自己完善compar函数的比较是必须的。
所以只要掌握了qsort函数就能对任意类型的数据进行排序了。
4、模拟qsort函数
使用冒泡排序的算法，模拟实现一个排序函数，并且可以兼容任意类型的数据
bubble_sort();
整型数据/字符数据/结构体数据…
void bubble_sort(void* base, size_t num, size_t size, int (*cmp)(const void* e1, const void* e2))
{
//冒泡排序的趟数
int i = 0;
int j = 0;
for (i = 0; i < num - 1; i++)
{
//一趟冒泡排序
for (j = 0; j < num - 1 - i; j++)
{
//括起来的核心部分，不同需改造，外面的循环部分是相同的，不做更改
//
//if (arr[j] > arr[j + 1])
//{
// int temp = arr[j];
// arr[j] = arr[j + 1];
// arr[j + 1] = temp;
//}
//
if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
{
//交换 --- 拆分为每一位的字节交换 --- size/char = size
swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
}
}
}
}
解释说明：
发现正题架构依然采用的冒泡排序的思路，简单的说就是完善了兼容任意的数据类型排序；
那么具体代码是如何实现的呢？然后我们模拟qsort函数，至于函数的参数参看qsort技术文档就能明白，
void* base 就是表示待排序的第一个元素地址，那么设计一个满足任意类型的函数排序，所以需要用void接收地址，其他的void也同理；然后，第二个参数num，也就是待排序的个数；第三个参数size，指的就是待排序的元素，其字节的大小，通常以sizeof(arr[0])计算所得；最后一个参数，是我们前面所学的函数指针，指针指向的cmp函数功能完成两个元素的比较，但这个函数是用户自己需要写，因为只有用户在知道使用这个函数去对什么类型的数据排序。
然后明白了参数的设置，跳过熟知的冒泡排序的外围框架，直接来到该函数的内核部分，我们明白冒泡排序的思想，是比较相邻的两个元素大小，然后排序；同理，要想实现任意类型的元素大小比较，我们就需要思考如何像冒泡int整型数据一样比较大小，交换位置呢？
探究，int是4个字节，然后进行比较就是4个字节4个字节的进行比较，
比如：4，3比较，以升序排为例
以十六进制表示为：
0x00 00 00 04 ---- 4
0x00 00 00 03 ---- 3
比较发现 4 > 3，交换4和3的位置，直接是4个字节进行交换即可；
这里我们就明白了，交换的关键点就是字节的方式进行操作，那么我们就可以以void类型强转为(char*)类型，
那么就可以用base起始地址加宽度也就是偏移相应的字节，进行操作。最后同样以一个字节类型进入swap进行交换即。
现在完整的模拟实现qsort函数，代码如下所示：
#include <stdio.h>
//#include <stdlib.h>
#include <string.h>
struct Stu
{
char name[20];
int age;
};
void print(int* arr, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
printf("\n");
}
void print_struct(struct Stu* arr, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%s %d\n", arr[i].name, arr[i].age);
}
printf("\n");
}
void swap(char* buf1, char* buf2, size_t size)
{
int i = 0;
for (i = 0; i < size; i++)
{
char temp = *buf1;
*buf1 = *buf2;
*buf2 = temp;
buf1++;
buf2++;
}
}
void bubble_sort(void* base, size_t num,size_t size,int (*cmp)(const void* e1,const void* e2))
{
//冒泡排序的趟数
int i = 0;
int j = 0;
for (i = 0; i < num - 1; i++)
{
//一趟冒泡排序
for (j = 0; j < num - 1 - i; j++)
{
//if (arr[j] > arr[j + 1])
if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
{
//交换 --- 拆分为每一位的字节交换 --- size/char = size
swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
}
}
}
}
int cmp_int(const void* e1, const void* e2)
{
return *(int*)e1 - *(int*)e2;
}
void test1()
{
int arr[] = {
9,8,7,6,5,4,3,2,1,0 };//降序
//排序为升序
int sz = sizeof(arr) / sizeof(arr[0]);
//bubble_sort(arr, sz);
print(arr, sz);
//模拟实现整型排序
bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
print(arr, sz);
}
int cmp_by_age(const void* e1,const void* e2)
{
return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
void test2()
{
struct Stu arr[] = {
{
"zhangsan",20},{
"lisi",30},{
"wangwu",15} };
int sz = sizeof(arr) / sizeof(arr[0]);//3
print_struct(arr, sz);
bubble_sort(arr, sz, sizeof(arr[0]), cmp_by_age);
print_struct(arr, sz);
}
int cmp_by_name(const void* e1, const void* e2)
{
return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
void test3()
{
struct Stu arr[] = {
{
"zhangsan",20},{
"lisi",30},{
"wangwu",15} };
int sz = sizeof(arr) / sizeof(arr[0]);//3
print_struct(arr, sz);
bubble_sort(arr, sz, sizeof(arr[0]), cmp_by_name);
print_struct(arr, sz);
}
int main()
{
test1();//模拟排序整型数据
//test2();//模拟排序结构体 -- 以年龄
//test3();//模拟排序结构体 -- 以姓名
return 0;
}
5、结语
半亩方糖一鉴开，天光云影共徘徊。
问渠哪得清如许?为有源头活水来。–朱熹（观书有感）