文章目录
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
目标数组是开始。
你要排序的数据的起始位置就需要传到 base 里面，
- num
元素个数（数组大小）
- width
元素的宽度，也就是一个元素占几个字节
比如 int 占 4 个字节、char 占 1 个字节
- compare
比较函数
- elem1 和 elem2
传给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 ∗ w i d t h 0 * width 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 加多少，就跳过多少个字节的大小👇
259
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
