-
c语言进阶篇：指针(二)
✨作者介绍：大家好，我是摸鱼王胖嘟嘟，可以叫我小嘟💕
✨作者主页：摸鱼王胖嘟嘟的个人博客主页.🎉
🎈作者的gitee: 小比特_嘟嘟的个人gitee
🎈系列专栏： 【从0到1，漫游c语言的世界】
✨小嘟和大家一起学习，一起进步！尽己所能，写好每一篇博客，沉醉在自己进步的喜悦当中🤭。如果文章有错误，欢迎大家在评论区✏️指正。让我们开始今天的学习吧！😊
💻前言
🍁大家好哇~今天要来接着讲指针进阶了，话不多说，让我们开始今天的学习吧！
🎈函数指针
✏️函数指针定义
🍁函数指针：指向函数的指针，用来存放函数的地址的。
#includeint Add(int x, int y) { return x + y; } int main() { int (*p1)(int, int) = &Add; /* p1是个函数指针, 用来存放函数的地址的 通过对p1进行解引用,可以找到这个函数 * - 表示p1是个指针,int(int,int)表示p1指向的这个函数的类型 指针p1的类型是int(*)(int,int) */ int (*p2)(int x, int y) = &Add;//也可以 int (*p3)(int, int) = Add; //对于函数来说,&函数名和函数名都是函数的地址,所以这样写也可以 printf("%p\n", p1);//007010B4 printf("%p\n", p2);//007010B4 printf("%p\n", p3);//007010B4 return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
🍁如何通过对函数指针p1解引用找到这个函数,调用这个函数呢？
#includeint Add(int x, int y) { return x + y; } int main() { int (*p1)(int, int) = &Add; int ret = (*p1)(3, 5); //(*p1) - 对p1解引用,找到了这个函数 //(*P1)(3,5) - 给函数传参,调用这个函数 printf("%d\n", ret);//8 return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
那么之前我们是如何调用函数呢？对比如图：
#includeint Add(int x, int y) { return x + y; } int main() { int ret = Add(3, 5); printf("%d\n", ret);//8 return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
而且我们会发现：
在获取函数地址时,&和不加&都可以;
在通过函数名调用函数时,*和不加 *都可以。🍁阅读两段有趣的代码：
//代码1 (*(void (*)())0)(); //代码2 void (*signal(int , void(*)(int)))(int);- 1
- 2
- 3
- 4
🎉代码1解释：
这串代码可以分成3部分来看
先看绿色部分，这是一个函数指针类型，我们可以通过这个类型知道这个指针指向的函数大概是这样的：void test()
然后看红色部分，(类型)是强制类型转换，将int型的0强制类型转换成void test(*)类型，即整数0变成了函数的地址0
最后看黑色部分，(*函数的地址)()，这不就是函数的调用吗，调用的函数大概是这样的：void test()
所以，这串代码就是一次函数的调用，调用的是0作为地址处的函数。🍁这串代码用到的知识：
1.指针的使用
2.函数指针的类型和它指向的函数息息相关
3.强制类型转换🎉代码2解释：
首先我们看红色部分，signal是函数名，int是整型
void(*)(int)是函数指针类型
黑色部分 void( * )(int)也是函数指针类型
函数声明的构成：返回类型 函数名(参数类型,参数类型)
所以，以上代码是一次函数声明。
声明的signal函数的第一个参数的类型是int，第二个参数类型是函数指针void( * )int，该函数指针指向的函数参数是int，返回类型是void，signal函数的返回类型也是一个函数指针，该函数指针指向的函数参数是int，返回类型是int。但是这样的代码可读性特别差。
因为函数指针类型void(*)(int)两次被用到，可以用typdef把类型进行重命名，
对这个函数指针类型进行重命名的格式为 typedef void( * 重命的名)(int)上面的代码2就可以写成这样：
typedef unsigned int unit; //typedef void(*)(int) pf_t； //这样写是错误的 typedef void(*pf_t)(int);//这样写才对，意思是把void(*)(int)类型重命名成pf_t #includeint main() { pf_t signal(int, pf_t); return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
✏️函数指针的应用：
#include//函数的嵌套调用 int Add(int x, int y) { return x + y; } int cal() { return Add(3, 5); } int main() { int ret = cal(); printf("%d\n", ret); return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
#includeint Add(int x, int y) { return x + y; } //在cal函数中调用Add函数 int cal(int(*pf)(int,int))//函数的地址用函数指针来接收 { int ret = (*pf)(3, 5); printf("%d\n", ret); } int main() { cal(Add); return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
2.真正的函数指针的应用（写一个简单版计算器） ：
//写一个计算器 //加法、减法、乘法、除法 #includevoid menu() { printf("*******************************\n"); printf("******* 1. add *********\n"); printf("******* 2. sub **********\n"); printf("******* 3. mul **********\n"); printf("******* 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("请输入操作数:>"); scanf("%d %d", &x, &y); ret = pf(x, y); printf("%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; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
🎈函数指针数组
🍁函数指针数组，是个数组，是用来存放函数指针的数组。
#includeint main() { int a = 10; int b = 20; int c = 30; //要将&a,&b,&c这三个地址放在一个数组中,需要这三个地址的类型相同。 int* pa = &a;//刚好这三个地址的类型都是int* int* parr[3] = { &a,&b,&c }; //parr是个数组,数组里有3个元素,每个元素的类型都是int* return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
发现指针数组和它存放的指针只是parr[3]和pa的区别
于是得到函数指针数组：#includeint 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() { //要将Add,Sub,Mul,Div这四个地址放到一个数组中，需要这四个地址的类型相同 int (*pf)(int, int) = Add;//刚好这四个地址的类型都是int(*)(int,int) int (*arr[4])(int, int) = { Add,Sub,Mul,Div }; //arr数组中有4个元素，每个元素的类型是int(*)(int,int) return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
那么如何调用呢？
int main() { int (*arr[4])(int, int) = { Add,Sub,Mul,Div }; int i = 0; for (i = 0; i < 4; i++) { printf("%d\n", arr[i](3, 5));//调用函数 //通过arr[i]找到每个函数名,通过函数名调用函数 } return 0; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
效果如下：
✏️函数指针数组应用
写一个计算器：实现简单的加减乘除
用函数指针数组，大大减少了重复代码。 转移表#includevoid menu() { printf("*******************************\n"); printf("******* 1. add *********\n"); printf("******* 2. sub **********\n"); printf("******* 3. mul **********\n"); printf("******* 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; } int main() { int input = 0; int x = 0; int y = 0; int ret = 0; int (*pf_arr[])(int, int) = { 0,Add,Sub,Mul,Div };//函数指针数组是直接将不同的函数名存到了数组中， //通过数组下标就可以访问数组中的不同函数名,从而找到对应的函数进行函数调用 do { menu(); printf("请选择:>"); scanf("%d", &input); if (input == 0) { printf("退出计算器\n"); } else if ((input >= 1) && (input <= 4)) { printf("请输入操作数:>"); scanf("%d %d", &x, &y); ret = pf_arr[input](x, y); printf("%d\n", ret); } else { printf("选择错误\n"); } } while (input); return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
为什么说大大减少了重复代码呢？
来看下面的做法：（实现一个计算器）
普通做法：（代码重复率特别高）#includevoid menu() { printf("*******************************\n"); printf("******* 1. add *********\n"); printf("******* 2. sub **********\n"); printf("******* 3. mul **********\n"); printf("******* 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; } 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; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
于是进行改进：
函数指针的做法：函数名传过来用函数指针接收，
通过传过来的不同函数名，可以找到对应的函数进行函数调用//计算 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("%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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
函数指针数组的做法：
函数指针数组是直接将不同的函数名存到了数组中，
通过数组下标就可以访问数组中的不同函数名,从而找到对应的函数进行函数调用int main() { int input = 0; int x = 0; int y = 0; int ret = 0; int (*pf_arr[])(int, int) = { 0,Add,Sub,Mul,Div };//函数指针数组是直接将不同的函数名存到了数组中， //通过数组下标就可以访问数组中的不同函数名,从而找到对应的函数进行函数调用 do { menu(); printf("请选择:>"); scanf("%d", &input); switch (input) { case 1: case 2: case 3: case 4: printf("请输入操作数:>"); scanf("%d %d", &x, &y); ret = pf_arr[input](x, y); printf("%d\n", ret); break; case 0: printf("退出计算器\n"); break; default: printf("选择错误\n"); break; } } while (input); return 0; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
是不是感觉函数指针和函数指针数组的做法更简单呢，大大减少了代码的重复率。
当然，下面这两部分代码的功能是一样的。
那么，我们可能会产生疑问，函数指针和函数指针数组有什么区别呢？用函数指针和函数指针数组来实现计算器又有什么区别呢？
✏️函数指针和函数指针数组的区别：
函数指针是指向函数的指针，里面存放的是函数的地址，可以是函数名，从而通过函数名找到对应的函数，进行函数调用。
函数指针数组是存放函数指针的数组，里面存放的是不同函数的地址，可以是不同的函数名，我们可以通过数组下标访问数组中的元素（函数名），从而通过函数名找到对应的函数，进行函数调用。✏️用函数指针和函数指针数组来实现计算器的区别：
函数指针实现计算器：函数名传过来用函数指针接收，通过传过来的不同函数名，可以找到对应的函数进行函数调用
函数指针数组实现计算器：函数指针数组是直接将不同的函数名存到了数组中，通过数组下标就可以访问数组中的不同函数名,从而找到对应的函数进行函数调用 -
相关阅读:
偏向锁理论太抽象，实战了解下偏向锁如何发生以及如何升级【实战篇】
Java 8 新特性解读及应用实践
python永久配置pip下载镜像源方法（window版本）
Python股票市场的风险管理
虚拟机安装VMwares Tools
Qt 将qsqlite数据库中的数据导出为Excel表格
【JavsSE】数组的定义与使用
C++ 基础与深度分析 Chapter11 类与面向对象编程（构造函数：缺省、单一、拷贝、移动、赋值）
竞赛选题 深度学习手势识别算法实现 - opencv python
【SG滤波】三阶滤波、五阶滤波、七阶滤波（Matlab代码实现）
- 原文地址：https://blog.csdn.net/weixin_61341342/article/details/126033759
