C语言 --- 进阶指针（接上篇，已完结）

最新推荐文章于 2023-07-11 23:31:25 发布

努力学习.java

最新推荐文章于 2023-07-11 23:31:25 发布

阅读量1.1k

点赞数 18

本文链接：https://blog.csdn.net/qq_61688804/article/details/123481381

版权

函数指针回调函数 qsort 排序算法 C语言

关键词由CSDN通过智能技术生成

嗨害嗨，我又来了，接着来更新我们的进阶指针的内容，这篇文章是接着上篇的内容的，因为考虑到篇幅过长看着太累，所以就把这后面的内容分了出来，如果大家想看完整的主页就有，欢迎大家来一起交流！

好了，废话我说完了，我们开始正片..........

7，指向函数指针数组的指针

7.1，定义及其基本使用

定义：首先是一个指针，这个指针指向的是函数指针数组。

使用：

#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;
}

int main() {
	int (*pfarr[4])(int, int) = { ADD,Sub,Mul,Div };//pfarr是一个函数指针数组
	int (*(*p)[4])(int, int) = &pfarr;//p就是一个指向函数指针数组的指针
	for (int i = 0;i < 4;i++) {
		int ret = (*p)[i](3, 4);
		printf("%d ", ret);
	}



}

这里主要就是要注意一个如何访问这个函数指针数组元素的问题，p是指向这个函数指针数组的指针，对其解引用就相当于拿到了整个数组，也就是拿到了数组名，数组名又等价于首元素地址，在首元素地址上加i再解引用就拿到了对应位置上的函数指针，这个时候就可以直接调用了。

8，回调函数

8.1，定义

定义：回调函数，回调函数就是一个通过函数指针调用的函数。例如我们要调用A函数，但是我们不直接调用，而是把A函数的地址传给B函数，在B函数里面用一个函数指针接收，并且通过该函数指针调用A函数，此时A函数就叫做回调函数。

8.2，使用

int cal(int (*p)(int,int)) {
	int a = 0;
	int b = 0;
	printf("请输入两个操作数>>>");
	scanf("%d %d", &a, &b);
	printf("计算结果为 %d\n", p(a, b));
}
int main() {
	int ret = 0;
	do {
		menu();
		printf("请输入您想要进行的计算操作>>>");
		scanf("%d", &ret);
		switch (ret) {
		case 0:
			printf("退出计算器!\n");
			break;
		case 1:
			cal(ADD);
			break;
		case 2:
			cal(Sub);
			break;
		case 3:
			cal(Mul);
			break;
		case 4:
			cal(Div);
			break;
		default:
			printf("输入错误!\n");
			break;
		}
	} while (ret);
	return 0;
}

上面是简易计算器的部分代码，在我们起初用switch实现的时候会发现代码十分的冗余，在使用回调函数后，可以将共同的部分封装成函数，对于不同的计算功能只需要传入不同的函数地址即可，在封装好的函数里面用函数指针实现调用，这样就可以大大降低代码的冗余度。

9，qsort排序函数(重点理解)

qsort是一个库函数，是基于快速排序算法实现的一个排序的函数

首先，对于排序，很多人会想到冒泡排序，如下：

void Bubblesort(int arr[10],int sz) {
	for (int i = 0;i < sz - 1;i++) {
		for (int 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;
			}
		}
	}
	for (int i = 0;i < 10;i++) {
		printf("%d ", arr[i]);
	}

}
int main() {
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	Bubblesort(arr,sz);
	return 0;
}

但是，对于冒泡排序的缺点，就是每次比较的对象固定死了，比如这里你只能比较整形的数据，所以，相对于冒泡排序，qsort就具有很强的普适性，无论什么数据，都能进行比较。

所以，接下来我们引出qsort，那么qsort是什么？

可以看到，qsort是一个库函数，并且有很多的参数，下面会有各个参数的释意。

这个比较函数的返回值是取决于elem 1 和 emel 2 的大小，当elem 1 大于 emel 2 时，返回值大于0，二者就会进行交换，所以在默认的逻辑下，传入的数据就是升序排列的。

对于后面的自定义比较函数，是需要我们根据实际情况自己去定义的，因为像结构体类型的有些数据，你是不能用大于号小于号来进行比较的。然后要将函数地址传给qsort里面的这个函数指针参数，这样就可以调用到这个比较函数了。

代码实现：

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

解析：在这段代码中，compareint就是我们自定义的比较函数，用来比较前后两个数的大小，对于qsort函数而言，需要我们做的就是传参，自定义一下比较函数，当前面的数比后面的数大，也就是返回值大于0时，就会进行交换，当然这个交换函数是不需要我们自己去写的，编译器会帮我们完成交换。至于compareint函数里面的两个参数是用来接收待比较的两个数的地址的，将他们定义为void*类型的目的也就是可以接收任何类型的数据。但是这里注意一点，就是我们要对其比较，解引用拿值的时候是不能直接解引用的，因为el1,el2这两个指针都是空类型的，解引用根本就不知道该访问几个字节，所以这个时候我们需要将其转换为其对应的类型的指针后，再进行解引用。

看完上面的比较整形了后，我们来点不一样的，对结构体变量来进行排序。

代码实现：

struct stu {
	char name[20];
	int age;
	double score;
};
int comparestruct(const void* el1, const void* el2) {
	//return ((struct stu*)el1)->age - ((struct stu*)el2)->age;//以年龄作为比较对象
	return strcmp(((struct stu*)el1)->name, ((struct stu*)el2)->name);//以名字作为比较对象
}
int main() {
	struct stu arr1[3] = { {"zhangsan",17,77.8} ,{"lisi",66,56.7} ,{"wangwu",23,99.1} };
	int sz = sizeof(arr1) / sizeof(arr1[0]);
	qsort(arr1, sz, sizeof(arr1[0]), comparestruct);
	return 0;
}

1，以年龄作为排序标准。

2，以名字作为排序标准(字符串的比较要用特定的strcmp比较函数)

以上就是qsort的使用介绍，但是我们会发现，qsort的默认逻辑都是升序，那怎么改成降序呢？很简单，将el1 与 el2 的位置互换即可。就比如比较3 ，5 按照原本的逻辑，el1的值减去el2的值就是负的，就是不需要交换，所以也就是升序，如果我们将el1,el2二者位置互换，那么相减的值大于0了，就要交换，就变成了 5 ，3，也就实现了降序的排列。(说到这可能有的同学会觉得直接在前面加个负号就是一样的意思嘛，逻辑上好像说得通，但是实际试了试是不行的)

10，qsort函数模拟实现

在上面介绍完了qsort的实现，但是对于原理我们都不太清楚，所以接下来会模拟实现下qsort，清晰的阐述下qsort的深层排序原理。

代码实现：

//利用冒泡排序的原理，模拟实现一个类似于qsort的通用冒泡排序函数
void swap(char* buf1,char* buf2,int width) {
	for (int i = 0;i < width;i++) {
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}
int compareint(const void* el1, const void* el2) {
	return (*(int*)el1) - (*(int*)el2);
}
//函数的声明
void Bubblesort(void* Base, int num, int width, int (*cmp)(const void* el1, const void* el2)) {
	for (int i = 0;i < num - 1;i++) {
		for (int j = 0;j < num - 1 - i;j++) {
			//if (arr[j] > arr[j + 1]) {传进来的数据不一定是整形的，所以这里是不能直接用大于号小于号比较的
			if (cmp((char*)Base + j * width, (char*)Base + (j + 1) * width) > 0) {
				swap((char*)Base + j * width, (char*)Base + (j + 1) * width, width);
			}
		}
	}
}
int main() {
    int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
    int sz = sizeof(arr) / sizeof(arr[0]);
    Bubblesort(arr,sz,sizeof(arr[0]),compareint);
    for (int i = 0;i < 10;i++) {
          printf("%d ", arr[i]);
    }
    return 0;	

}

同理，在后面交换的时候，swap函数中，我们也是用的char*指针接受的两个待交换的数，因为在交换的时候就可以一个字节一个字节的交换，这样就能适用于所有的数据。注意我们上面转换为char*的指针都只是为了使指针能够一个字节一个字节的移动，都只是在指针的层面上，和这个地址里面存的数据的类型没有任何关系，不会影响到里面的数据。

好了，到这里进阶指针的内容就更完了，当然后面还会有其他知识的相关文章，希望大家还是能继续关注，我们一起学习进步，对于我说的有问题的地方也请大家帮忙指正，十分感谢。

下次再会咯！