【C语言航路】第十站：指针进阶（二）

news2024/11/18 6:40:01

目录

六、函数指针数组

七、指向函数指针数组的指针

八、回调函数

1.回调函数的概念

2.回调函数实现计算器

3.回调函数实现冒泡排序

总结

六、函数指针数组

我们已经知道了函数指针，它的类型是int(*)(int,int)。那么我们能否进行推广呢？将其推广成一个数组，答案是可以的。我们只需要加上一个[]，就成了数组

如下代码所示

#include<stdio.h>
int my_strlen(const char* p)
{
	return 0;
}
int main()
{
	//pf是函数指针
	int (*pf)(const char*) = &my_strlen;
	//pfA是函数指针数组
	int (*pfA[5])(const char*) = { my_strlen };
	return 0;
}

那么这个函数指针数组有什么用呢？我们这里举一个例子，比如说当我们想写一个计算器的时候，按照我们之前的方法是这样写的

#include<stdio.h>
void meau()
{
	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;
}
int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	do
	{
		meau();
		printf("请输入你的操作>:\n");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("请输入两个操作数：\n");
			scanf("%d %d", &x, &y);
			ret=Add(x, y);
			printf("%d\n", ret);
			break;
		case 2:
			printf("请输入两个操作数：\n");
			scanf("%d %d", &x, &y);
			ret = Sub(x, y);
			printf("%d\n", ret);
			break;
		case 3:
			printf("请输入两个操作数：\n");
			scanf("%d %d", &x, &y);
			ret = Mul(x, y);
			printf("%d\n", ret);
			break;
		case 4:
			printf("请输入两个操作数：\n");
			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;
}

这样写是没问题，但是当未来计算器的功能逐渐增多的时候，那么这个代码就显得有点冗杂了。那么我们该如何解决这个问题呢？

我们可以这样做，使用一个函数指针数组来记录每一个函数的地址，我们通过下标i来进行调用函数，如下代码所示

#include<stdio.h>
void meau()
{
	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;
}
int (*pf[5])(int, int) = { NULL,Add,Sub,Mul,Div };
int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;

	do
	{
		meau();
		printf("请输入你的操作>:\n");
		scanf("%d", &input);
		if (input == 0)
		{
			printf("退出计算器\n");
		}
		else if((input>=1) && (input<=4) )
		{
			printf("请输入两个操作数：\n");
			scanf("%d %d", &x, &y);

			ret = pf[input](x, y);
			printf("%d\n", ret);
		}
		else
		{
			printf("选择错误，请重新选择\n");
		}
	} while (input);
	return 0;
}

而这个函数指针数组其实还有一个名字叫做转移表，因为我们通过下标可以跳转到其他的函数

七、指向函数指针数组的指针

我们已经知道了函数指针数组，那么指向函数指针数组的指针其实也不难理解，就是将这个数组的地址取出来，放到一个指针里面去，这个指针的类型，就如同一个数组的地址放入一个数组指针中一样。

#include<stdio.h>
int main()
{
	//数组指针
	int arr[10];
	int(*pa)[10] = &arr;

	//指向函数指针数组的指针
	int (*pf[5])(int, int);
	int (*(*ppf)[5])(int, int) = &pf;
	return 0;
}

八、回调函数

1.回调函数的概念

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该时间或条件进行响应。

2.回调函数实现计算器

听概念似乎有点难以理解，我们用上面的计算器的那个例子

我们会发现在一开始的计算器的版本中，有太多的相似的部分，我们能否将其封装成一个函数呢？答案始可以的，我们这些的区别就只是函数的不一样的，所以我们只需要传一个函数的地址，通过函数指针来调用这个函数就可以了

#include<stdio.h>
void meau()
{
	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;
	printf("请输入两个操作数：\n");
	scanf("%d %d", &x, &y);
	int ret = pf(x, y);
	printf("%d\n", ret);
}
int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	do
	{
		meau();
		printf("请输入你的操作>:\n");
		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;
}

3.回调函数实现冒泡排序

我们知道冒泡排序的基本思想，就是两个相邻元素两两比较，假设有10个元素，第一趟比较9次，可以将一个最大的数放到最后面，然后第二趟比较8次，又可以搞定一个数，一共比较9次就能实现排序，这是它的基本实现

#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] = { 10,9,8,7,6,5,4,3,2,1 };
	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有四个参数

第一个是一个base，它的类型是指针，也就是要被排序的数组要传入到这里，这个base的类型是void，目的是为了接收任意类型的数组，因为void类型就像一各垃圾桶，任意一个类型的指针的都可以传入进去。

第二个是num，它的类型是size_t，这个参数是传入数组的元素个数

第三个是size，这个参数的意思是数组的每个元素的类型的字节大小，也就是宽度

第四个是compar，这是一个函数指针，这个函数指针所指向的函数有两个参数，一个是e1，一个是e2，当e1的大小大于e2时，返回一个大于0的数，等于则返回0，小于则返回小于0的一个数，这个其实也就是一个回调函数，这个compar是需要我们自定义出来的

我们来使用一下这个库函数

如下代码所示，我们使用qsort去排序了一个整型数组

int cmp(const void* e1,const void* e2)
{
	return (*(int*)e1) - (*(int*)e2);
}
int main()
{
	int arr[10] = { 10,9,8,7,6,5,4,3,2,1 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	//bubble_sort(arr, sz);
	qsort(arr, sz, sizeof(arr[0]), cmp);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

那么我们接下来来实现排序一个结构体

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct Stu
{
	char name[20];
	int age;
};
//按照年龄比较
int cmp_by_stu_age(const void* e1,const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
//按照名字比较
int cmp_by_stu_name(const void* e1, const void* e2)
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
int main()
{
	struct Stu s[3] = { {"zhangsan",20},{"lisi",50},{"wangwu",18} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_by_stu_age);
	qsort(s, sz, sizeof(s[0]), cmp_by_stu_name);
	return 0;
}

那么我们现在会了qsort的使用，我们可不可以使用qsort来类比着写一个万能的冒泡排序呢？答案是可以的，我们现在就来实现

#include<stdio.h>
#include<string.h>
void Swap(char* buf1, char* buf2, size_t size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
void bubble_sort(void* base, size_t sz, size_t size, int (*cmp)(const void*, const void*))
{
	size_t i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		size_t j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			//如果前一个大于后一个的话
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				//交换
				Swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}
struct Stu
{
	char name[20];
	int age;
};
//按照年龄比较
int cmp_by_stu_age(const void* e1,const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
//按照名字比较
int cmp_by_stu_name(const void* e1, const void* e2)
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
int main()
{
	struct Stu s[3] = { {"zhangsan",20},{"lisi",50},{"wangwu",18} };
	int sz = sizeof(s) / sizeof(s[0]);
	bubble_sort(s, sz, sizeof(s[0]), cmp_by_stu_age);
	bubble_sort(s, sz, sizeof(s[0]), cmp_by_stu_name);
	return 0;
}

这段代码需要的注意的是：为了让我们的普适性更强，所以我们需要的base参数必须是void类型，这个指针是void类型的话，为了确定我们的指针步长，我们需要传一个元素的字节大小，然后通过我们的char*类型的强制类型转化， 即可走到每一个元素的起始地址，有了起始地址，我们可以通过回调函数，来调用比较函数。根据比较函数输出的结果，来确定是否进行交换，由于我们不知道传了一个什么类型的数据，所以我们需要强制类型转化为char*类型，结合宽度，来进行一个字节一个字节的交换。这样一来，我们就实现了普适性更强的冒泡排序

总结

本小节讲解了函数指针数组，指向函数指针数组的指针，回调函数的使用，以及如何使用qsort和如何实现普适性更强的冒泡排序

如果对你有帮助的话，不要忘记一键三连哦！！！

想获得更多优质内容，那么一定要关注我哦！！！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/149500.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

基于AD Event日志实时检测DSRM后门

基于AD Event日志实时检测DSRM后门

01、简介每个域控制器都有一个目录还原模式&#xff08;DSRM&#xff09;帐户&#xff0c;它的密码是在安装域控时设置的&#xff0c;实际上它对应的就是sam文件里的本地管理员“administrator”&#xff0c;基本很少会被重置&#xff0c;因此有着极强的隐蔽性。攻击者通过获取…
阅读更多...
面试篇之NoSQL

面试篇之NoSQL

面试篇之NoSQL一、redis持久化1.1、字节1.2、微软1.3、题解1.3.1、RDB快照1.3.2、AOF日志1.3.3、最佳实践二、redis删除策略2.1、字节2.2、阿里云2.3、题解2.3.1、过期删除2.3.2、内存淘汰2.3.3、LRU2.3.4、LFU三、redis高可用3.1、字节3.2、美团3.3、微软3.4、题解3.4.1、主从…
阅读更多...
前端性能优化（六）：传输加载优化

前端性能优化（六）：传输加载优化

目录 一&#xff1a;启用压缩 Gzip 二&#xff1a;启用 Keep Alive 三&#xff1a;HTTP 资源缓存 3.1.HTTP 缓存方案 3.2.各大网站缓存策略参考 四&#xff1a;Service Worker 五&#xff1a;HTTP2 的性能提升 5.1.HTTP2 优势 5.2.开启 HTTP2 5.3.Server Push&#x…
阅读更多...
【Spring（五）】带你深入了解bean的生命周期

【Spring（五）】带你深入了解bean的生命周期

1.5 bean的生命周期 bean的实例化已经说完了&#xff0c;我们最后再来讲讲bean的生命周期。 我们主要来围绕着bean生命周期控制来学习&#xff0c;那么什么是生命周期呢&#xff1f;其实就是一个东西从创建到消亡的完整过程&#xff0c;比如人从出生到死亡的整个过程&#xff…
阅读更多...
【MySQL进阶】深入理解redoLog日志

【MySQL进阶】深入理解redoLog日志

【MySQL进阶】深入理解redoLog日志 文章目录【MySQL进阶】深入理解redoLog日志一&#xff1a;redo日志概述二&#xff1a;redo日志格式三&#xff1a;Mini-Transaction1&#xff1a;以组的形式写入redo日志2&#xff1a;Mini-Transaction的概念四&#xff1a;redo日志的写入过程…
阅读更多...
富淼转债，优彩转债上市价格预测

富淼转债，优彩转债上市价格预测

富淼转债基本信息转债名称&#xff1a;富淼转债&#xff0c;评级&#xff1a;A&#xff0c;发行规模&#xff1a;4.5亿元。正股名称&#xff1a;富淼科技&#xff0c;今日收盘价&#xff1a;18.25&#xff0c;转股价格&#xff1a;20.26。当前转股价值 转债面值 / 转股价格 * …
阅读更多...
(3分钟速览)SLAM中的三大金刚-H E F Matrix

(3分钟速览)SLAM中的三大金刚-H E F Matrix

编辑切换为居中添加图片注释&#xff0c;不超过 140 字&#xff08;可选&#xff09;三个矩阵的自由度&#xff1a;单应矩阵H 自由度8基础矩阵F 自由度7本质矩阵E 自由度5或者8&#xff0c;这个是根据使用旋转矩阵还是旋转向量编辑切换为居中添加图片注释&#xff0c;不超过 14…
阅读更多...
每日一题之Vue的异步更新实现原理是怎样的？

每日一题之Vue的异步更新实现原理是怎样的？

最近面试总是会被问到这么一个问题&#xff1a;在使用vue的时候&#xff0c;将for循环中声明的变量i从1增加到100&#xff0c;然后将i展示到页面上&#xff0c;页面上的i是从1跳到100&#xff0c;还是会怎样&#xff1f;答案当然是只会显示100&#xff0c;并不会有跳转的过程。…
阅读更多...
计算机基础——计算机应用领域以及未来发展趋势

计算机基础——计算机应用领域以及未来发展趋势

作者简介&#xff1a;一名云计算网络运维人员、每天分享网络与运维的技术与干货。 座右铭&#xff1a;低头赶路&#xff0c;敬事如仪 个人主页&#xff1a;网络豆的主页​​​​​​ 目录 前言 一.计算机应用领域 1.信息管理 2.过程控制 3.计算机辅助技术 1&#xff09…
阅读更多...
一天天过去，每天该如何过？

一天天过去，每天该如何过？

刚跨了年&#xff0c;又快到春节&#xff0c;日子就这样一天天过去。如何过好这一生是个大命题&#xff0c;不如简化点考虑下如何过好一天&#xff1f;人的时间大体分为两类&#xff1a;主动的&#xff0c;可以自由支配&#xff1b;被动的&#xff0c;等着被安排。过去我在互联…
阅读更多...
MCU-51：LCD1602详解

MCU-51：LCD1602详解

目录一、LCD1602简介1.1 显示原理1.2 引脚及应用电路1.3 技术参数1.4 引脚功能1.5 指令集1.6 连接方式二、时序图2.1 写时序2.2 读时序三、代码演示3.1 LCD1602.c3.2 示例注意&#xff1a;一定要看一、LCD1602简介 LCD1602&#xff08;Liquid Crystal Display&#xff09;液晶…
阅读更多...
能量加油站Java上

能量加油站Java上

1、final 在 Java 中有什么作用&#xff1f; 1、final 修饰的类叫最终类&#xff0c;该类不能被继承。2、final 修饰的方法不能被重写3、final 修饰的变量叫常量&#xff0c;常量必须初始化&#xff0c;初始化之后值就不能被修改 2、Math.round() 指向上取整 补充 Double.do…
阅读更多...
01背包问题再探

01背包问题再探

原题&#xff1a; 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi&#xff0c;价值是 wi。 求解将哪些物品装入背包&#xff0c;可使这些物品的总体积不超过背包容量&#xff0c;且总价值最大。 输出最大价值。 输入格式 第一行两个整…
阅读更多...
盖子的c++小课堂——第五讲：for 循环

盖子的c++小课堂——第五讲：for 循环

前言 hi&#xff0c;大家好&#xff0c;我是盖子的盖&#xff0c;最近大家都放假了吗&#xff0c;反正我还没有&#xff0c;我们期末考才刚开始考呜呜呜&#xff0c;真羡慕那些放假了的童鞋们~~(╥╯^╰╥)~~ 好啦&#xff0c;废话不多说&#xff0c;开始今天的小课堂吧~~ 上…
阅读更多...
厚积薄发打卡Day113：Debug设计模式：设计原则（一）＜开闭原则、依赖倒置、单一职责＞

厚积薄发打卡Day113：Debug设计模式：设计原则（一）＜开闭原则、依赖倒置、单一职责＞

厚积薄发打卡Day113&#xff1a;Debug设计模式&#xff1a;设计原则&#xff08;一&#xff09;<开闭原则、依赖倒置、单一职责> 开闭原则 定义 一个软件实体如类、模块和函数应该对扩展开放&#xff0c;对修改关闭。其优点&#xff1a;提高软件系统的可复用性及可维护…
阅读更多...
JavaEE多线程-创建线程(Thread)

JavaEE多线程-创建线程(Thread)

目录一、线程(Thread)1.1 Thread类中的构造方法1.2 启用线程的方法二、创建第一个多线程三、多线程并发执行简单演示四、多线程并发执行的优势五、Thread的常见构造方法和属性5.1 属性5.2 方法六、中断线程七、线程等待一、线程(Thread) 线程是操作系统中的概念. 操作系统内核…
阅读更多...
LeetCode二叉树经典题目（六）：特殊位置构造二叉树

LeetCode二叉树经典题目（六）：特殊位置构造二叉树

目录 21. LeetCode404. 左叶子之和 22.LeetCode513. 找树左下角的值 23. LeetCode112. 路径总和 24. LeetCode113. 路径总和 II 25. LeetCode106. 从中序与后序遍历序列构造二叉树 26. LeetCode105. 从前序与中序遍历序列构造二叉树​编辑 27. LeetCode654. 最大二叉树 …
阅读更多...
LED、Mini LED、Micro LED、LCD、OLED技术

LED、Mini LED、Micro LED、LCD、OLED技术

1、传统led、miniled、microled的异同 2、OLED OLED&#xff08;Organic Light-Emitting Diode&#xff09;&#xff0c;又称为有机电激光显示、有机发光半导体&#xff08;Organic Electroluminescence Display&#xff0c;OLED&#xff09;。OLED属于一种电流型的有机发光器…
阅读更多...
S32K144-hello_word点灯

S32K144-hello_word点灯

官方提供了很多的参考例程&#xff0c;每个历程分别配置了不同的外设&#xff0c;这里挨个尝试解读一下。 示例效果 RGB红灯绿灯交替闪烁。 导入示例 示例文件所在目录&#xff1a; 该示例使用PCC和PORT模块交替切换两个LED。 硬件连接 配置引脚功能 生成代码 S32DS自带引…
阅读更多...
C#上位机基础学习_登录窗体的创建方法和步骤

C#上位机基础学习_登录窗体的创建方法和步骤

C#上位机基础学习_登录窗体的创建方法和步骤 本次和大家分享如何制作一个简单的登录窗体。具体的方法和步骤可以参考以下内容： 如下图所示，打开Visual Studio 2019，新建一个Windows 窗体应用（.NET Framework）, 如下图所示，在窗体中添加Label标签、Text文本框、Button按…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023