1. 函数指针
函数指针，顾名思义，就是指向函数的指针，函数 有没有地址呢？
#include <stdio.h>
void test(){ printf("hehe\n");}
int main(){ printf("%p\n", test); printf("%p\n", &test); return 0;}
复制代码
运行结果👇
在数组里面，数组名 拿到首元素的地址；&数组名 拿到整个数组的地址。
在函数里面，函数名 和 &函数名 拿到的都是函数的地址，函数是没有首元素概念的。
函数的地址，就是函数存放的位置
那么函数的地址用什么来接收呢？代码如下👇
int Add(int x, int y){ return x + y;}
void test(char* str){}
int main(){ int arr[5]; int (*pa)[5] = &arr; //pa是数组指针 int (* pf)(int, int) = &Add; // pf是函数指针 int (* pf)(int, int) = Add; // 也可以直接用函数名
void (*pt)(char*) = test;
return 0;}
复制代码
pf 旁边放一颗 *，说明它是指针，指针指向的是函数，函数的参数类型是 int、int，返回类型也是 int
当然函数也有无返回类型，pt 先和 * 结合，说明 pt 是指针，指针指向的是一个函数，指向的函数无参数，返回值类型为 void。
那么我们如何调用这个函数呢？我们以 pf 为例👇
阅读两段有趣的代码：
代码一：
1、把 0 强制类型转换为 void (*)() 类型的函数指针 2、再去调用 0 地址处这个参数为 无参，返回类型是 void 的函数 这是依次函数调用，调用 0 地址处的函数
代码二：
signal 是一个函数声明； 这个函数的参数有 2 个，第一个是 int 类型，第二个是函数指针，该指针指向的函数参数 int，返回类型是 void； signal 函数的返回类型也是函数指针，该指针指向的函数参数 int，返回类型是 void
是不是觉得代码二很复杂？那能不能把它简化呢？
我们可以这样写
2. 函数指针数组
数组是一个存放相同类型数据的存储空间，那我们已经学习了指针数组，如下
int* arr[10];// 数组的每个元素是int*
复制代码
那要把函数的地址存到一个数组中，那这个数组就叫 函数指针数组，那函数指针的数组如何定义呢？
int (*parr1[10])();int *parr2[10]();int (*)() parr3[10];
复制代码
上面给出了 3 中定义方式，正确的是：parr1
parr1 先和 [ ] 结合，说明 parr1 是数组，数组的内容是什么呢？
是 int (*)() 类型的函数指针。
🍑 函数指针数组的用途
我们学习了 函数指针 和 函数指针数组，那么在实际场景如何运用呢？
我们这里以一个 计算器 小程序为例
示例一
写一个计算机小程序，能够实现基本的四则运算
📝代码实现
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, y; 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"); } } while (input); return 0;}
复制代码
运行结果👇
这样子写法是完全正确的，但是如果我要实现 按位与、按位或、左移、右移 呢？
那我岂不是又要去 mian 函数里面添加，这样子很麻烦，有没有化简实现呢？
这时候就需要用到使用 函数指针数组 去实现了；
示例二
对示例一的计算器进行化简升级
📝代码实现
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) = { 0, Add, Sub, Mul, Div };//pfArr是一个函数指针的数组，也叫转移表
do { menu(); printf("请选择:>"); scanf("%d", &input); if (input == 0) { printf("退出计算器\n"); break; } else if (input >= 1 && input <= 4) { printf("输入2个操作数:>"); scanf("%d %d", &x, &y); ret = pfArr[input](x, y); printf("ret = %d\n", ret); } else { printf("选择错误\n"); } } while (input);
return 0;}
复制代码
当然运算结果也肯定是一样的，这里就不演示了
3. 指向函数指针数组的指针
指向函数指针数组的指针是一个 指针
指针指向一个 数组 ，数组的元素都是 函数指针 ;
如何定义？
这里给举个例子👇
可能看到这里还是有点懵😵
别急，我们把上面的 计算器 小程序重新来改进一下
📝代码实现
void menu(){ printf("**********************************\n"); printf("***** 1. add 2. sub *****\n"); printf("***** 3. mul 4. div *****\n"); printf("***** 0. exit *****\n"); printf("**********************************\n");}
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 (*pf)(int, int)){ int x = 0; int y = 0; int ret = 0; printf("输入2个操作数:>"); 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;}
复制代码
当然运行结果肯定也和上面一样的
分析一下 calc 函数
在 main 函数里，我们传了 Add、Sub、Mul、Div，它们都是不同的函数地址，
那么在 calc 函数里面，我们要用指针 pf 来接收，函数类型是 int、int，返回类型是 void
4. 回调函数
回调函数就是一个 通过函数指针调用的函数。
如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。
回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
在上面的 计算器 小程序中，我们没有直接的去调用 Add、Sub、Mul、Div 这四个函数，而且传给了 calc，当在 calc 函数内部时，准备了 2 个数去计算，我们直接通过 pf 指针去计算。
是不是有点难理解？别急，这里再通过几个示例来讲讲 回调函数
🍑 冒泡排序
一说到排序，脑海里面第一时间想到的都是冒泡排序，那么我这里就来写一个冒泡排序
📝代码实现
//冒泡排序void bubble_sort(int arr[], int sz) { int i = 0; int j = 0; //趟数 for (i = 0; i < sz - 1; i++) { //每一趟冒泡排序的过程 //确定的一趟排序中比较的对数 for (j = 0; j < sz - 1 - i; j++) { if (arr[j] > arr[j + 1]) { int tmp = arr[j + 1]; arr[j + 1] = arr[j]; arr[j] = tmp; } } }}
void print(int arr[], int sz) { int i = 0; for (i = 0; i < sz; i++) { printf("%d ", arr[i]); }}
int main(){ int arr[] = { 1,4,2,6,5,3,7,9,0,8 }; int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr, sz);
print(arr, sz); return 0;}
复制代码
运行结果
🍑 qsort 排序
上面的冒泡排序使用起来当然很好，但是会存在一个问题，就是使用起来会很局限？
假设我要对 float、struct 等其它类型的数据进行排序呢？
那么有没有一种现成的排序模板呢？
其实在 C 语言中有一个库函数叫 qsort，它是用快速排序的方法实现的。
里面有些参数是不需要用到的，整理一下，如下
第一个参数是 void 类型的指针；
第二个参数是 整型；
第三个参数是 整型；
第四个参数是 函数指针，compare 和 * 结合，说明它是指针，指针外面指向一个函数，该函数有 2 个参数，返回类型是 int
下面我们对参数进行分析
目标数组是开始。你要排序的数据的起始位置就需要传到 base 里面，
元素个数（数组大小）
元素的宽度，也就是一个元素占几个字节比如 int 占 4 个字节、char 占 1 个字节
比较函数
传给 compare 用来比较的元素
对于 compare，还要遵循几个因素
如果 elem1 指向的元素 小于 elem2 指向的元素，那么就返回 小于 0 的数字；
如果 elem1 指向的元素 大于 elem2 指向的元素，那么就返回 大于 0 的数字；
如果 elem1 指向的元素 等于 elem2 指向的元素，那么就返回 0 ；
qsort 排序整型数组
了解 qsort 函数的基本情况以后，我们就来使用它，对上面的 arr 数组重新进行排序；
📝代码实现
#include <stdio.h>#include <stdlib.h>
void print(int arr[], int sz) { int i = 0; for (i = 0; i < sz; i++) { printf("%d ", arr[i]); }}
void cmp_int(const void* e1, const void* e2) { return *(int*)e1 - *(int*)e2;}
int main(){ int arr[] = { 1,4,2,6,5,3,7,9,0,8 }; int sz = sizeof(arr) / sizeof(arr[0]);
qsort(arr, sz, sizeof(arr[0]), cmp_int);
print(arr, sz); return 0;}
复制代码
cmp_int 是创建的 比较函数 ，它的作用就是：比较 e1 和 e2 指向的元素
*(int*)e1 ：对 e1 强制类型转换为 int*， 然后解引用，访问一个字节；
*(int*)e2 ：对 e2 强制类型转换为 int*， 然后解引用，再向后访问一个字节；
这里要讲一下关于 void* 的知识点
void* 是一种无类型的指针，无具体类型的指针 void* 的指针变量可以存放任意类型的地址 void* 的指针不能直接进行解引用操作 void* 的指针不能直接进行 +-整数
qsort 排序结构体
我们定义一个结构体，要求结构体里面有 姓名、年龄、成绩；
要求使用 qsort 函数按照 成绩 来对结构体成员排序
📝代码实现
#include <stdio.h>#include <stdlib.h>
struct Stu{ char name[20]; int age; float score;};
int cmp_stu_by_socre(const void* e1, const void* e2){ if (((struct Stu*)e1)->score > ((struct Stu*)e2)->score) { return 1; } else if (((struct Stu*)e1)->score < ((struct Stu*)e2)->score) { return -1; } else { return 0; }}
void print_stu(struct Stu arr[], int sz){ int i = 0; for (i = 0; i < sz; i++) { printf("%s %d %f\n", arr[i].name, arr[i].age, arr[i].score); } printf("\n");}
void test1(){ struct Stu arr[] = { {"zhangsan",20,87.5f},{"lisi",22,99.0f},{"wangwu", 10, 68.5f} };
int sz = sizeof(arr) / sizeof(arr[0]);
// 按照成绩来排序 qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_socre); //打印结构体成员 print_stu(arr, sz); return 0;}
int main(){ test1(); return 0;}
复制代码
运行结果👇
还可以按照 年龄 来排序
📝代码实现
#include <stdio.h>#include <stdlib.h>
struct Stu{ char name[20]; int age; float score;};
int cmp_stu_by_age(const void* e1, const void* e2){ return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;}
void print_stu(struct Stu arr[], int sz){ int i = 0; for (i = 0; i < sz; i++) { printf("%s %d %f\n", arr[i].name, arr[i].age, arr[i].score); } printf("\n");}
void test1(){ struct Stu arr[] = { {"zhangsan",20,87.5f},{"lisi",22,99.0f},{"wangwu", 10, 68.5f} };
int sz = sizeof(arr) / sizeof(arr[0]);
// 按照年龄来排序 qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
print_stu(arr, sz); return 0;}
int main(){ test1(); return 0;}
复制代码
运行结果👇
当然，肯定还可以按照 姓名 来排序
📝代码实现
#include <stdio.h>#include <stdlib.h>
struct Stu{ char name[20]; int age; float score;};
int cmp_stu_by_name(const void* e1, const void* e2){ return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);}
void print_stu(struct Stu arr[], int sz){ int i = 0; for (i = 0; i < sz; i++) { printf("%s %d %f\n", arr[i].name, arr[i].age, arr[i].score); } printf("\n");}
void test1(){ struct Stu arr[] = { {"zhangsan",20,87.5f},{"lisi",22,99.0f},{"wangwu", 10, 68.5f} };
int sz = sizeof(arr) / sizeof(arr[0]); qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name); print_stu(arr, sz); return 0;}
int main(){ test1(); return 0;}
复制代码
运行结果👇
注意：名字 排序是根据首字母的 ASCII 码值来比较的；
模拟实现 qsort
既然学会了 qsort 函数的使用，那么我们来模仿 qsort 的功能实现一个通用的冒泡排序；
📝代码实现
#include <stdio.h>
int cmp_int(const void* e1, const void* e2){ return *(int*)e1 - *(int*)e2;}
void print_arr(int arr[], int sz){ int i = 0; for (i = 0; i < sz; i++) { printf("%d ", arr[i]); } printf("\n");}
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++; }}
void bubble_sort(void* base, int sz, int width, int(*cmp)(const void* e1, const void* e2)){ int i = 0; for (i = 0; i < sz - 1; i++) { int j = 0; for (j = 0; j < sz - 1 - i; j++) { if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0) { //两个元素的交换 Swap((char*)base + j * width, (char*)base + (j + 1) * width, width); } } }}
void test2(){ int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
print_arr(arr, sz);}
int main(){ test2(); return 0;}
复制代码
运行结果👇
其实这段代码很简单，但是理解起来的话，还是有点难度，别急，下面我们一起来看一看
代码解析：
我们先来梳理一下调用逻辑：
首先我们从 test2 函数出发，在函数内部，调用 bubble_sort 函数
在 bubble_sort 函数的参数部分：
1、arr 传的就是数组第 1 个元素 9 的地址，形参部分用 base 接收
2、sz 就是元素个数 10，形参部分用 sz 接收
3、sizeof(arr[0]) 就是一个 int 的大小 4 个字节，形参部分用 width 接收
4、cmp_int 是一个函数，相当于传的就是函数的地址，形参部分用指针 cmp 接收，cmp 就指向创建的 cmp_int 函数
我们再来详细说下 bubble_sort 函数和 cmp_int 函数
我们在 if 语句里面传的两个值，其实通过 函数指针 跑去 cmp_int 函数里，调用 e1 和 e2 去了；
把 (char*)base + j * width 传给了 e1，(char*)base + (j + 1) * width 传给了 e2，然后 e1 和 e2 进行计算，计算好之后的结果（返回类型是 int）再与 if 语句里面的 0 进行比较；
如果返回结果是 大于 0 的，说明 e1 大于 e2，那我们就把 e1 和 e2 进行交换，而交换的时候，又去调用我们的 Swap 函数；
所以核心思路就是：把 cmp_int 函数的地址传给 bubble_sort，用一个 cmp 指针来接收，再通过这个 cmp 指针去调用这个函数的。
关于 Swap 函数，这里就不过多解释，其实就是个交换的实现。
❗ 这里在重点说一下：(char*)base + j * width, (char*)base + (j + 1) * width 这段代码
这里拿结构体代码来举例👇
首先我创建的结构体类型一共是 28 个字节；
在 test1 函数里，定义的 arr 一共有 3 个结构体，那么在内存中应该是下面这样👇
在 test1 函数里：
把 arr 传给了 base，base 相当于指向了第一个 28 的地址，但是如果我们要比较第一个 28 和第二个 28 呢？
是不是还需要 base 指向的下一个元素的地址
其实 问号 处的地址很简单，我们来看 bubble_sort 函数内部的 if 语句：
1、当 j = 0 时，也就是 0∗width，宽度就是 sizeof(arr[0]) 的计算结果，也就是 28；
所以就是：(char*)base + 0 和 (char*)base + 28
因为我是 char* 强转之后的 base，所以 (char*) base + 0 还是首元素的地址；
因为我是 char* 类型的指针，所以 (char*) base + 28 跳过 28 个字节，因为这个结构体正好是 28 个字节👇
2、当 j = 1 时
就是：(char*) base + 1 * 28 和 (char*) base + (1 + 1) * 28；
因为我们是把 base 强制类型转换成了 char* 的指针，而 char* 的指针就可以理解为 1，base 加多少，就跳过多少个字节的大小👇
评论