6. 函数指针数组
之前我们已经学习过指针数组，比如整型指针数组等，因此我们可以以此进行类比：
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; } int main() { //int (*pf1)(int, int) = Add; //int (*pf2)(int, int) = Sub; //int (*pf3)(int, int) = Mul; //int (*pf4)(int, int) = Div; //函数指针数组 int (*pfArr[4])(int, int) = { Add, Sub, Mul, Div };//pfArr先和[]结合，说明pfArr是数组，数组的内容int (*)(int, int)类型的函数指针。 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); switch (input) { case 1: printf("请输入两个操作数:"); scanf("%d %d", &x, &y); ret = Add(x, y); printf("ret = %d\n", ret); break; case 2: printf("请输入两个操作数:"); scanf("%d %d", &x, &y); ret = Sub(x, y); printf("ret = %d\n", ret); break; case 3: printf("请输入两个操作数:"); scanf("%d %d", &x, &y); ret = Mul(x, y); printf("ret = %d\n", ret); break; case 4: printf("请输入两个操作数:"); 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; }
我们可以发现以上代码的switch语句中用许多代码是重复的
解决方法：使用函数指针数组
#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; //函数指针数组的使用 - 转移表 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("ret = %d\n", ret); } else if (0 == input) { printf("退出计算器\n"); } else { printf("选择错误，重新选择\n"); } } while (input); return 0; }
7. 指向函数指针数组的指针
指向函数指针数组的指针是一个指针，指针指向一个数组，数组的元素都是函数指针。
void test(const char* str) { printf("%s\n", str); } int main() { void (*pf)(const char*) = test;//pf是函数指针变量 void (*pfArr[10])(const char*);//pfArr是存放函数指针的数组 void (*(*p)[10])(const char*) = &pfArr;//p是指向函数指针数组的指针 return 0; }
8. 回调函数
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
计算器的实现就可以用到回调函数：
#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"); } void Calc(int (*pf)(int, int)) { int x = 0; int y = 0; int ret = 0; printf("请输入两个操作数:"); scanf("%d %d", &x, &y); ret = pf(x, y); printf("ret = %d\n", ret); } int main() { int input = 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; }
我们再举一个使用回调函数的例子：qsort函数（标准库中有一个函数qsort，是用来排序的）
说到排序，我们先来复习一下冒泡排序：
//冒泡排序 //有一组整数，需要排序为升序 //1. 两两相邻的元素比较 //2. 如果不满足顺序就交换 #include <stdio.h> void bubble_sort(int arr[], int sz) { int i = 0; //趟数 for (i = 0; i < sz - 1; i++) { //一趟比较 //两两相邻元素比较 int j = 0; for (j = 0; j < sz - 1 - i; j++) { if (arr[j] > arr[j + 1]) { int tmp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = tmp; } } } } int main() { int arr[10] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 }; int sz = sizeof(arr) / sizeof(arr[0]); bubble_sort(arr, sz); int i = 0; for (i = 0; i < sz; i++) { printf("%d ", arr[i]); } return 0; }
但是我们会发现以上代码只适合于整型数据，而qsort函数就可以解决这个问题。
qsort函数的特点：
- 使用了快速排序的方法
- 适合于任意类型数据的排序
接下来，我们就学习一下如何使用qsort函数：
void qsort(void* base,//指向了需要排序的数组的第一个元素 size_t num,//排序的元素个数 size_t size,//一个元素的大小，单位是字节 int (*compar)(const void*, const void*)//函数指针类型 - 这个函数指针指向的函数，能够比较base指向数组中的两个元素 );
这里先对 void* 进行一个解释：
//void* 的指针 - 无具体类型的指针 //void* 类型的指针可以接收任意类型的地址 //这种类型的指针是不能直接解引用操作的 //也不能直接进行指针运算的 int main() { int a = 10; float f = 3.14f; int* pa = &a; //char* pc = &a;//err void* pv = &a; pv = &f; //*pv;//err //pv++;//err return 0; }
接着我们来看一下qsort函数具体是如何使用的：
#include <stdio.h> #include <stdlib.h> #include <string.h> int cmp_int(const void* p1, const void* p2) { return (*(int*)p1 - *(int*)p2);//通过改变p1和p2的位置来改变升降序 } void print(int arr[], int sz) { int i = 0; for (i = 0; i < sz; i++) { printf("%d ", arr[i]); } } //测试qsort排序整型数据 void test1() { int arr[10] = { 3, 1, 5, 2, 4, 7, 9, 6, 8, 0 }; int sz = sizeof(arr) / sizeof(arr[0]); //默认是升序的 qsort(arr, sz, sizeof(arr[0]), cmp_int); print(arr, sz); } //测试qsort排序结构体数据 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; } void test2() { struct Stu arr[] = { {"zhangsan", 20}, {"lisi", 50}, {"wangwu", 15} }; int sz = sizeof(arr) / sizeof(arr[0]); qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age); } int cmp_stu_by_name(const void* p1, const void* p2) { return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name); } void test3() { struct Stu arr[] = { {"zhangsan", 20}, {"lisi", 50}, {"wangwu", 15} }; int sz = sizeof(arr) / sizeof(arr[0]); qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name); } int main() { test1(); test2(); test3(); return 0; }
学会了qsort函数如何使用，那么我们能不能自己模拟实现一个qsort函数呢？
因为目前我们还没有学习快速排序算法，所以我们使用冒泡排序的思想，实现一个功能类似qsort的函数bubble_sort：
- 使用冒泡排序的思想
- 适用于任意类型数据的排序
首先，通过观察我们之前写的冒泡排序代码，我们发现它的参数只能接收整型数组，因此，我们需要使用一个 void* 的指针；同时，作为代码的实现者，我们不知道 void* 的指针指向的数组元素是什么类型的，所以我们还需要知道数组中一个元素的大小。
其次，对于不同类型的数据，不能简单地使用 > 比较，所以我们要在参数部分加上函数指针cmp，将实现2个元素比较的这一个函数的地址，以参数的形式传递过来。
最后，不同的数据，在交换的时候也略有差异，具体应该怎么实现，在写代码的时候再进行讲解。
#include <string.h> //每个元素的首地址和一个元素的大小我们都知道，因此，我们可以通过一个字节一个字节的交换，来实现两个元素的交换（这样就能解决不同数据在交换时候的差异了） void Swap(char* buf1, char* buf2, int size)//交换下标为j和j+1的这两个元素 { int i = 0; char tmp = 0; for (i = 0; i < size; i++) { tmp = *buf1; *buf1 = *buf2; *buf2 = tmp; buf1++; buf2++; } } void bubble_sort(void* base, int num, int size, int (*cmp)(const void*, const void*)) { int i = 0; //趟数 for (i = 0; i < num - 1; i++) { int j = 0; //一趟内部比较的对数 for (j = 0; j < num - 1 - i; j++) { //假设需要升序，cmp返回>0，交换 if (cmp((char*)base+j*size, (char*)base+(j+1)*size) > 0)//两个元素比较，需要将下标为j和j+1的元素的地址传给cmp { //交换 Swap((char*)base+j*size, (char*)base+(j+1)*size, size); } } } } 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; } //测试bubble_sort 排序结构体数据 void test2() { struct Stu arr[] = { {"zhangsan", 20}, {"lisi", 50}, {"wangwu", 15} }; int sz = sizeof(arr) / sizeof(arr[0]); bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_age); } int cmp_stu_by_name(const void* p1, const void* p2) { return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name); } void test3() { struct Stu arr[] = { {"zhangsan", 20}, {"lisi", 50}, {"wangwu", 15} }; int sz = sizeof(arr) / sizeof(arr[0]); bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_name); } int cmp_int(const void* p1, const void* p2) { return (*(int*)p1 - *(int*)p2); } //测试bubble_sort 排序整型数据 void test1() { int arr[10] = { 3, 1, 5, 2, 4, 7, 9, 6, 8, 0 }; int sz = sizeof(arr) / sizeof(arr[0]); bubble_sort(arr, sz, sizeof(arr[0]), cmp_int); } int main() { test1(); test2(); test3(); return 0; }
