六. 函数指针数组
要把函数的地址存到一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？
int (*parr[10])()
解释：parr1就是一个数组，数组的内容就是int (*)()类型的函数指针
1.函数指针的使用
写一个简单的计算器
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"); } #include<stdio.h> 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("请输入两个操作数:>"); scanf("%d %d", &x, &y); ret = Add(x, y); printf("%d\n", ret); break; case 2: printf("请输入两个操作数:>"); scanf("%d %d", &x, &y); ret = Sub(x, y); printf("%d\n", ret); break; case 3: printf("请输入两个操作数:>"); scanf("%d %d", &x, &y); ret = Mul(x, y); printf("%d\n", ret); break; case 4: printf("请输入两个操作数:>"); scanf("%d %d", &x, &y); ret = Div(x, y); printf("%d\n", ret); break; case 0: printf("退出计算器\n"); break; default: printf("选择错误\n"); break; } } while (input); return 0; }
以上代码有没有发现有些许冗余了，未来如果有需要添加整型的其他运算，如<< >> & | ^ ……等运算，代码太冗长，那有没有什么办法将代码给简化一下呢？直接上代码：
2.函数指针数组的应用
以下代码改为了转移表的形式，转移表主要用指针数组来实现，每个元素存一个函数指针，我们只要通过已定义好的编号来进行访问。
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"); } #include<stdio.h> int main() { int input = 0; int x = 0; int y = 0; int ret = 0; //转移表 int (*pfarr[5])(int,int) = { NULL,Add,Sub,Mul,Div }; //0 1 2 3 4 do { menu(); printf("请选择:>"); scanf("%d", &input); if (input >= 1 && input <= 4) { printf("请输入两个操作数：>"); scanf("%d %d", &x, &y); ret = pfarr[input](x, y); printf("%d \n", ret); } else if (input == 0) { printf("退出计算器\n"); } else { printf("输入有误\n"); } } while (input); return 0; }
七. 指向函数指针数组的指针
指向函数指针数组的指针是一个 指针，该指针指向一个 数组 ，数组的元素都是 函数指针。
int Add(int x, int y) { return x + y; } int Sub(int x, int y) { return x - y; } int main() { int (*pf)(int, int) = Add; //函数指针数组 int (* pfArr[4])(int, int) = {Add, Sub}; // int (*(* ppfArr)[4])(int, int) = &pfArr;//ppfArr是一个指向函数指针数组的指针变量 return 0; }
以上代码中的int (*(* ppfArr)[4])(int, int)就是一个指向函数指针数组的指针，(* ppfArr)可以看出ppfArr是一个指针变量，加上[4]说明是一个数组指针，指针指向的是一个数组，该数组的元素是什么呢？剩余部分就是数组的元素类型了（函数指针），由此，我们将其一步步拆开看， 其实就是一个指针，指向的是一个数组，数组的每个元素类型是函数指针。
八. 回调函数
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
什么意思呢？
我们将上面函数指针数组部分写的简单计算器，觉得冗余的代码，应用在此场景，作出修改编写如下。
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"); } void Calc(int (*pf)(int,int)) { int i = 0, j = 0; printf("请输入两个整数:>"); scanf("%d %d", &i, &j); printf("%d\n", pf(i, j)); } #include<stdio.h> int main() { int input = 0; do { menu(); printf("请选择:>"); scanf("%d", &input); switch (input) { case 1: Calc(Add); case 2: Calc(Sub); case 3: Calc(Mul); case 4: Calc(Div); case 0: printf("退出计算器\n"); break; default: printf("输入有误\n"); break; } } while (input); return 0; }
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。
九、qsort函数的应用
qsort 为quick sort的简写，意为快速排序，主要用于对各种类型的数组进行排序，需要引用头文件中
下面我们来看看它的用法
首先我们在 https://legacy.cplusplus.com/ 网站的旧版本，找到对qosrt函数具体规则的描述。
在搜索框搜索qsort，显示如下：
观察以上图的绿色字体部分，就是官方对于qsort函数的声明
void qsort(void* base, size_t num, size_t size, int (*compar)(const void*, const void*))
解释：
base -- 指向要排序的数组的第一个元素的指针。
num -- 由 base 指向的数组中元素的个数。
size -- 数组中每个元素的大小，以字节为单位。
compar -- 用来比较两个元素的函数
qsort可以排序任意类型的数据
如果读者知道冒泡排序的算法，是如何实践的，我们可能就知道在比较两个整型的时候，可以用大于小于操作符来比较，在比较字符串的时候，我们可以使用strcmp函数，但是对于两个结构体数据，指定的比较的标准是什么呢？
所以我们不妨设计统一的标准，使各种类型数组元素都可以进行排序，具有通用性。
qsort在声明函数时的参数int (*compar)(const void*, const void*)就是让使用者，指定一个比较的方法（使用者写一个函数，对应此时的函数指针的标准），那么compar函数指针的具体规则是什么呢？
函数指针指向的函数，比较的是两个元素的大小，而p1和p2是待排序的两个元素的地址。
如果p1指向的元素小于p2指向的元素，则返回值是一个小于0的数值；
如果p1指向的元素等于p2指向的元素，则返回值是一个等于0的数值；
如果p1指向的元素大于p2指向的元素，则返回值是一个大于0的数值。
（0默认排序为升序，若想要排序为降序，将p1与p2调换即可）
话不多说，下面直接上代码。
1.利用qsort来排序整型数组
void print_arr(int arr[], int sz) { int i = 0; for (i = 0; i < sz; i++) { printf("%d ", arr[i]); } printf("\n"); } //void表示无具体类型的指针，他可以接收任何类型的地址 int compar(const void* p1, const void* p2) { //使用者在使用的时候需要访问几个字节， //就需要进行强制类型转换，为指向的元素类型是什么类型的指针 //如元素地址是int*类型，就需要强制转换为int* return *(int*)p1 - *(int*)p2; //若将p1和p2调换，则打印的是降序顺序 } #include<stdlib.h> #include<stdio.h> int main() { int arr[] = { 9,8,7,6,5,4,3,2,1,0 }; int sz = sizeof(arr) / sizeof(arr[0]); //qsort默认排成升序 qsort(arr, sz, sizeof(arr[0]), compar); print_arr(arr,sz); return 0; }
将结果打印：
2 利用qsort来排序结构体数据
首先编写一个简单的结构体
struct Stu { char name[20]; int age; }; int main() { struct Stu s[] = { {"zhangsan",20},{"lisi",18},{"wangwu",30}}; return 0; }
按照年龄的大小来排序（升序）
struct Stu { char name[20]; int age; }; //按照年龄来排序 int cmp_stu_by_age(const void* p1,const void* p2) { return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age; } #include<stdio.h> #include<stdlib.h> int main() { struct Stu s[] = { {"zhangsan",20},{"lisi",18},{"wangwu",30}}; int sz = sizeof(s) / sizeof(s[0]); qsort(s, sz, sizeof(s[0]), cmp_stu_by_age); return 0; }
按F10调试代码，
排序后的结果正是我们想要的结果
数组从小到大排列，age分别是18,20,30
按照名字的大小来排序（升序）
字符串比较大小需要用到strcmp函数，在比较字符串时, 按照一位一位进行比较,本质比较的是其字符的ACSII码值，若字符串的第一位字符串的ASCII码值与另一个字符串的第一位字符的ASCII码值相等，继续向后比较两者的第二位ASCII码值、第三位……以此类推。
strcmp（）函数的比较规则如下： 需要引用头文件
如果字符串1的第n位的ASCII码值大于字符串2的第n位的ASCII码值 则输出结果:1,表示字符串1 > 字符串2;
如果字符串1与字符串2每一位的ASCII码值都相等,而且长度相同, 则输出结果:0 表示字符串1 == 字符串2；
字符串1的第n位的ASCII码值小于字符串2的第n位的ASCII码值，则输出结果:-1 表示字符串1 < 字符串2;
struct Stu { char name[20]; int age; }; //按照名字来排序 int cmp_stu_by_name(const void* p1, const void* p2) { return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name); } #include<stdio.h> #include<stdlib.h> #include<string.h> int main() { struct Stu s[] = { {"zhangsan",20},{"lisi",18},{"wangwu",30}}; int sz = sizeof(s) / sizeof(s[0]); qsort(s, sz, sizeof(s[0]), cmp_stu_by_name); return 0; }
调试代码
排序后的结果正是我们想要的结果
字符串相比较，两两元素从第一个字符的ASCII码值进行比较，按照元素的大小，'l'<'w'<'z',第一个字符比较出了结果，就不需要进行比较第二个字符ASCII码值的大小了。
十、以冒泡排序的思想，模拟实现qsort函数
我们知道了qsort函数的用法，下面我们就使用冒泡排序的思想实现一个类似于qsort函数的适用于各种类型的冒泡排序。
先在main函数里，将排序的数组，和打印内容罗列下来。
#include<stdio.h> int main() { int arr[] = { 3,1,5,2,4,9,8,6,5,7 }; int sz = sizeof(arr) / sizeof(*arr); //sizeof(*arr)表示首元素 int i = 0; printf("排序前：>"); for (i = 0; i < sz; i++) { printf("%d ", arr[i]); } printf("\n"); bubble_sort(arr, sz, sizeof(*arr), cmp_int);//实现通用的冒泡排序 printf("排序后：>"); for (i = 0; i < sz; i++) { printf("%d ", arr[i]); } return 0; }
下面编写bubble_sort函数的内部逻辑：
//以冒泡排序思想模拟实现 //bubble_sort可以排序任意类型数组的数据 void bubble_sort(void* base,int num,int width,int (*cmp)(const void* p1, const void* p2)) { int i = 0; //趟数 for (i = 0; i < num - 1; i++) { int flag = 1;//假设该趟数有序 //每趟冒泡排序的过程 int j = 0; for (j = 0; j < num - 1 - i; j++) { //两两元素进行比较 //将base强转为char* + j乘以每个元素的大小， 相当于跳过了j*width个字节 //将base强转为char* + （j + 1）乘以每个元素的大小， 相当于跳过了(j+1)*width 个字节 if (cmp_int((char*)base + j * width, (char*)base + (j + 1) * width) > 0) { flag = 0;//有交换就置为0 //交换 //封装一个Swap函数，用来交换元素 Swap((char*)base + j * width, (char*)base + (j + 1) * width, width); } } if (flag == 1) break; } }
将两个元素的交换部分，封装一个Swap（）函数，专门在这个函数里面编写。
//传过来的是char*类型，如果要修改元素的大小，则需要将元素的每个字节进行交换 //所以这里也就是为什么要将width传递过来的原因了。 void Swap(char* buf1, char* buf2,int width) { int i = 0; for (i = 0; i < width; i++) { char tmp = *buf1; *buf1 = *buf2; *buf2 = tmp; buf1++; buf2++; } }
最后，使用者自己编写一个比较元素的大小的函数。
int cmp_int(const void* p1,const void* p2) { return *(int*)p1 - *(int*)p2; }
最后将整体代码放在下面。
int cmp_int(const void* p1,const void* p2) { return *(int*)p1 - *(int*)p2; } //传过来的是char*类型，如果要修改元素的大小，则需要将元素的每个字节进行交换 //所以这里也就是为什么要将width传递过来的原因了。 void Swap(char* buf1, char* buf2,int width) { int i = 0; for (i = 0; i < width; i++) { char tmp = *buf1; *buf1 = *buf2; *buf2 = tmp; buf1++; buf2++; } } //以冒泡排序思想模拟实现 //bubble_sort可以排序任意类型数组的数据 void bubble_sort(void* base,int num,int width,int (*cmp)(const void* p1, const void* p2)) { int i = 0; //趟数 for (i = 0; i < num - 1; i++) { int flag = 1;//假设该趟数有序 //每趟冒泡排序的过程 int j = 0; for (j = 0; j < num - 1 - i; j++) { //两两元素进行比较 //将base强转为char* + j乘以每个元素的大小， 相当于跳过了j*width个字节 //将base强转为char* + （j + 1）乘以每个元素的大小， 相当于跳过了(j+1)*width 个字节 if (cmp_int((char*)base + j * width, (char*)base + (j + 1) * width) > 0) { flag = 0;//有交换就置为0 //交换 //封装一个Swap函数，用来交换元素 Swap((char*)base + j * width, (char*)base + (j + 1) * width, width); } } if (flag == 1) break; } } #include<stdio.h> int main() { int arr[] = { 3,1,5,2,4,9,8,6,5,7 }; int sz = sizeof(arr) / sizeof(*arr); //sizeof(*arr)表示首元素 int i = 0; printf("排序前：>"); for (i = 0; i < sz; i++) { printf("%d ", arr[i]); } printf("\n"); bubble_sort(arr, sz, sizeof(*arr), cmp_int);//实现通用的冒泡排序 printf("排序后：>"); for (i = 0; i < sz; i++) { printf("%d ", arr[i]); } return 0; }
