【C语言学习笔记---指针进阶02】

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);}elseprintf("输入错误，请重新输入\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 = sizeswap((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 = sizeswap((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]);//3print_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]);//3print_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、结语

半亩方糖一鉴开，天光云影共徘徊。
问渠哪得清如许?为有源头活水来。–朱熹（观书有感）