神奇的库函数qsort【详解指向函数指针数组的指针、回调函数、模拟实现qsort函数】【C语言/指针/进阶/程序员内功修炼】【下】

前言

书接上回（ 指针【上】 指针【中】），已经详细讲解了字符指针/指针数组/数组指针/函数指针/数组参数、指针参数/函数指针数组各种指针的概念以及如何理解它们，接下来将详细讲解指向函数指针数组的指针、回调函数，以及通过所学知识，用冒泡排序模拟库函数qsort

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

1. 指向函数指针数组的指针是一个指针
2. 指针指向一个数组，数组的元素都是函数指针

将函数指针数组定义的形式，去掉指针名，然后在相同位置加上(*p)

(*p3)表示找到数组名，(*p3)[i]表示找到函数指针数组元素，(*p3)[i](3，4)表示找到函数并传参。这个指向函数指针数组的指针通过图能理解为它就是函数指针数组的管理员，就像数组指针一样，只不过这里的数组元素都是函数指针。照这样推下去，理论上可以无限套娃，但实际上不会用到太复杂的指针，所以理解它即可。

8. 回调函数

8.1 回调函数的定义

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

即不直接调用a函数，而是将a函数的地址传给b函数。而b函数需要用一个指针接收a函数的地址，并且通过这个指针在一定条件下调用a函数，这时a函数便被称为回调函数

8.2 回调函数的用法

8.2.1模拟实现计算器

由于代码段占用的篇幅过长，专门写了一篇博客，这里介绍了回调函数和函数指针数组的用法 通过模拟实现计算器掌握函数指针数组和回调函数的用法【C语言/指针/进阶】

8.2.2介绍库函数qsort

介绍库函数qsort

qsort要求使用者自定义一个比较函数，通过用户指定任意类型以任意方式排序，可以实现对任何类型的数据排序。

例如

//这是一个 比较 函数
int cmp_int(const void* e1, const void* e2)
{
	if (*(int*)e1 > *(int*)e2)
		return 1;
	else if (*(int*)e1 == *(int*)e2)
		return 0;
	else
		return -1；
}

以上使用了强制类型转换，解引用后就能把它当int型数据使用。对于int型，我们可以用>/进行比较，若强制类型转换为其他类型，需要实际情况比较。

以上代码可优化为：

int cmp_int(const void* e1, const void* e2)
{
	return (*(int*)e1 - * (int*)e2);
}

介绍void*指针

void是一种类型，我们知道，指针的类型决定了它在被解引用时访问内存的权限。void为空，它能接收任何类型的数据，包括结构体（自定义类型），所以直接对它进行解引用操作是错误的，因为编译器不知道你想要让它访问多大的内存空间、每次操作多少个字节。于是我们想到强制类型转换。

8.2.3 库函数qsort的使用

例子1.对int型数据排序

void print_arr(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}

int cmp_int(const void* e1, const void* e2)
{
	return (*(int*)e1 - * (int*)e2);
}

void test1()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	//排序为升序
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	print_arr(arr, sz);
}

int main()
{
	test1();
	return 0;
}

结果

例子2 对结构体排序

struct Stu
{
	char name[20];
	int age;
	double score;
};

int cmp_stu_by_age(const void* e1, const void*e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
void test2()
{
	struct Stu arr[3] = { {"zhangsan", 20, 55.5},
														{"lisi", 30, 88.0},
													{"wangwu", 10, 90.0}};
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
	//qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
  //也可以对姓名排序，按照字母表顺序
}
int main()
{
	test2();
	return 0;
}

为什么qsort函数的参数是这些？

1. 设计者在设计时不知道人们以后会使用它处理的数据的具体类型，所以void*使得它可以接收任意类型的数据。虽然不知道，但也不能对它进行修改，所以加上了const
2. num和width可以知道有多少个元素和大小
3. 因为比较的可能不止是int这种能用/==比较的数据，若要包含所有情况，这个函数将会很复杂。不同类型数据的比较是有差异的，所以将比较这个模块独立出来，由用户自定义一个比较函数，用什么方式比较就调用用户设计的比较函数即可。

8.3 以冒泡排序模拟实现库函数qsort

上面介绍库函数qsort是基于快排实现的一种普适排序函数，那么可以把它的快排模块换成冒泡排序吗？实际上使用任何排序算法都可以，只不过作者为了降低时间复杂度而使用了快排。

8.3.1 改造冒泡排序函数

将冒泡排序函数改造成一个像qsort那样接收类似的参数

1. 首先改造函数形参，顺便还改一下函数名，以表区分

2. 其次，如何才能将任意类型的数据进行排序呢？排序的过程就是将数据不断进行交换的过程，假若只对int型或char型数据交换，那么每次交换的单位长度（字节）就是4（32位）或1个字节。用单位长度为4个字节给char型数据交换不行，但用1个字节为单位长度给int类型数据交换就可以。也就是说，以最小的单位长度将数据进行交换，对任何比它大的数据都是适用的，只是次数不同。

3. 既然这样，冒泡排序的交换部分就应该强制类型转换为char型（本来只能交换指定类型），然后再进行交换。那么该如何修改呢？

4. 为了实现能对任何类型的数据进行排序这一功能，“比较”函数必不可少。函数将接收的两个元素的地址强转为需要的类型，然后返回解引用后的差（对于结构体是返回强转后在访问结构成员之差）。上面已经介绍过int型数据（例子1）和结构体中int型数据（例子2）的比较，类似的，假设要以结构体中的名字排序

strcmp( ((struct Stu*)e1)->name , ((struct Stu*)e2)->name);
}//名字是一个字符串，需要使用strcmp函数比较

---

5. 现在已经将两个指针分别指向两个要比较的元素，接下来就是交换函数了，这是一个双指针交换函数，只需传递以上两个指针和一个元素的长度即可。这个函数将每个元素以一个字节为单位，分成若干个长度相同的部分，直到将所有部分交换为止（详情见2点）

   注意这里的双指针不是逆序函数中的双指针，因为要交换两个元素对应字节的内容，所以两个指针要同时往后走

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

1. 总代码呈现

//定义结构体成员类型
struct Stu
{
	char name[20];
	int age;
	double score;
};

//比较函数
int cmp_stu_by_age(const void* e1, const void*e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}

//冒泡排序函数
void bubble_sort(void* base, int num, int width, int (*cmp)(const void*e1, const void*e2))
{
	int i = 0;
	for (i = 0; i < num - 1; i++)
	{
		int j = 0;
		for (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);
			}
		}
	}
}

//交换每个字节内容的函数
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 test5()
{
	struct Stu arr[3] = { {"zhangsan", 20, 55.5},{"lisi", 30, 88.0},{"wangwu", 10, 90.0} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
	//bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}
int main()
{
	test5();
	return 0;
}

结果如下（升序）

若将比较函数中返回的两元素之差的顺序颠倒，则为升序

总体梳理一下

虽然函数之间的调用看起来有些混乱，但只要静下心认真分析，按照顺序解读代码，还是不难的。假设其中的变量为某个值分析会更加容易理解，使问题不那么抽象。

以上便是本节的所有内容，关于指针的概念以及如何理解的部分到此就大概结束了（后期会根据所学知识补充），接下来将以讲解指针的题目的形式熟悉各种指针的使用。