C语言之指针进阶（4）回调函数，以及qsort库函数的模拟实现

---

---

前言

        本文主要讲述C语言中的回调函数，回调函数的概念、判断以及用法。另外，为了更加深入理解回调函数，本文中还增加了 qsort 排序函数的使用教程，以及 qsort 函数的模拟实现，希望对大家有所帮助

---

一、回调函数的概念

回调函数就是⼀个通过函数指针调用的函数。

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

简单来说，就是把一个函数a的地址传给另一个函数b，然后在函数b中通过接收的a函数地址调用函数a，此时a就是一个回调函数。

作用：增加了代码的灵活性和可扩展性

---

二、回调函数示例

1.简单定义一个加法函数，用另一个函数调用该函数，此时Add就是一个回调函数

#include <stdio.h>

//定义一个加法函数
int Add(int x, int y)
{
	return x + y;
}

int test(int(*pf)(int, int), int x, int y)
{
	//在test函数中通过pf调用Add函数
	return pf(x, y);
}

int main()
{
	//定义一个函数指针储存Add函数地址
	int(*padd)(int, int) = &Add;

	int ret = test(padd, 3, 4);

	printf("%d\n", ret);

	return 0;
}

运行结果：

2.为了感受回调函数的实际作用，比较两段实现计算器的代码

第一段：

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

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 a = 0;
	int b = 0;

	do
	{
		menu();
		printf("请选择：\n");
		scanf("%d", &input);

		switch (input)
		{
		case 1:
			printf("请输入两个操作数：\n");
			scanf("%d %d", &a, &b);
			printf("%d\n", Add(a, b));
			break;
		case 2:
			printf("请输入两个操作数：\n");
			scanf("%d %d", &a, &b);
			printf("%d\n", Sub(a, b));
			break;
		case 3:
			printf("请输入两个操作数：\n");
			scanf("%d %d", &a, &b);
			printf("%d\n", Mul(a, b));
			break;
		case 4:
			printf("请输入两个操作数：\n");
			scanf("%d %d", &a, &b);
			printf("%d\n", Div(a, b));
			break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("输入非法，请重新输入\n");
		}
	} while (input);

	return 0;
}

第二段：

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

void calc(int(*pf)(int, int))
{
	int a = 0;
	int b = 0;
	printf("请输入两个操作数：\n");
	scanf("%d %d", &a, &b);
	printf("%d\n", pf(a, b));
}

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 a = 0;
	int b = 0;

	do
	{
		menu();
		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");
		}
	} while (input);

	return 0;
}

对比来看，是不是第二段代码中的 switch 语句简洁许多，因为这些关于计算函数的类型相同，将重复的代码写进一个函数 calc 中，定义其形参为一个函数指针，想要使用哪个功能时传入对应函数的地址即可，这就是回调函数的一个好处

---

三、qsort库函数的学习使用

qsort函数就应用了回调函数，因此学习qsort不仅更加理解了回调函数，还学会了如何使用qsort进行复杂的数据排序，一举两得

qsort 位于<stdlib.h>头文件中

qsort 作为一个通用排序函数，其内部使用的是快速排序的算法，该函数用于对数组中的元素进行排序，数组元素可以是任意数据类型，比如整形、浮点型、结构体类型等。它之所以可以为任意类型的元素进行排序，靠的是它的第四个参数，它需要用户自己定义一个比较函数传入qsort，这时候qsort就会使用指定的比较方式进行排序

因此其需要回调函数

参数解释：

• base：是待排序数组的起始地址
• num：数组中元素的数量
• size：数组中每个元素的大小
• compar：是用户提供的比较函数的指针，这个比较函数的参数为两个 const void* 类型，并且该比较函数的返回值应遵从以下规定：
• 返回值可与 strcmp 函数类比，大于返回正数，小于返回负数，相等返回0
• 只有大于0时，qsort中会交换两元素位置进行排序

---

1.qsort 的使用

（1）升序排列一个整形数组，代码中需要注意的是 void* 类型的指针不能直接解引用，需进行强制类型转换，因为是整形数组，因此强制转换为整形指针类型。另外比较函数内部直接写成两数相减，不仅反映了两数大小比较，代码也更加简洁。

#include <stdio.h>
#include <stdlib.h>

//定义一个比较函数，返回p1-p2的值
//如果大于0，p1和p2将会在qsort中交换位置
//因此这是一个升序排列
int int_cmp(const void* p1, const void* p2)
{
	return *(int*)p1 - *(int*)p2;
}

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

	qsort(arr, sz, sizeof(arr[0]), int_cmp);

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

	return 0;
}

运行结果：

（2）降序排列整形数组，只需要改变相减顺序即可，这样就变成如果p2>p1，就交换两位置，因此就降序了（注：p1，p2也代表了两元素的起始位置，p1在p2的前面）

#include <stdio.h>
#include <stdlib.h>

//降序只需要改变p1与p2的相减顺序即可
int int_cmp(const void* p1, const void* p2)
{
	return *(int*)p2 - *(int*)p1;
}

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

	qsort(arr, sz, sizeof(arr[0]), int_cmp);

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

	return 0;
}

（3）结构体排序，定义一个学生的结构体类型，包括名字和年龄信息，使用typedef重命名类型为Stu。然后我们需要对结构体以姓名进行排序，这里用到 strcmp 库函数，它能比较两字符串大小，大于返回1，小于返回-1，相等返回0，刚好与我们规定的比较函数返回值一致。我们在比较函数内，除了强制转换为结构体类型外，还需要通过 . 符号引出成员name传给strcmp函数

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

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

//按名字排序
int stu_cmp(const void* p1, const void* p2)
{
	return strcmp((*(Stu*)p1).name, (*(Stu*)p2).name);
}

int main()
{
	Stu s1 = { "zhangsan", 20 };
	Stu s2 = { "lisi", 18 };
	Stu s3 = { "xiaoming", 22 };

	Stu S[] = { s1,s2,s3 };

	qsort(S, 3, sizeof(Stu), stu_cmp);

	for (int i = 0; i < 3; i++)
	{
		printf("%s %d\n", S[i].name, S[i].age);
	}

	return 0;
}

运行结果：

类比使用姓名排序，我们也可通过 . 符号引出age成员进行相减，来达到以年龄进行排序的结果

剩下的其他类型排序，大家自己动手试一试

综合以上代码，我们是不是发现每次我们自定义的函数都需要由 qsort 进行调用，这就是回调函数的意义，使代码更加灵活，功能更加强大。

---

2.qsort的模拟实现

为了更加理解 qsort 函数，我们可以试着自己模拟实现该函数，虽然我们并不清楚 qsort 函数底层代码是如何实现的。但我们可以通过我们已知比较熟悉的排序方法——冒泡排序。

（1）首先我们需要先定义好函数名和函数的形参，将函数名命名为 my_qsort ，形参就与原 qsort 保持一致

（2）写出冒泡排序的基本框架，这个熟悉冒泡排序的应该都了解，冒泡排序由两个 for 循环组成

（3）现在就需要写出对两个元素的比较的判断 if 语句了，由于 qsort 是面对任何数据类型进行排序的，我们就不知道用户会比较什么类型的数据，因此我们需要一种通用的写法，结合形参中的 size，以及比较函数的两个形参都是 const void*类型 ， 再回忆我们上面的使用qsort代码，我们是不是每次都把 const void*进行强转了，因此我们只需要传给 cmp 两个元素的起始地址就行了，那么这两个地址如何得到，就需要用到 size ，也就是每个元素的大小，我们将传过来的数组首元素地址 bass 进行强制类型转换为 char* 类型，在使用循环中的 j 跳过一个元素大小，来得到每个元素的起始地址。如下(j+1)*size 就比 j*size 多跳过一个元素地址，以此来得到每个相邻两个元素的地址

（4）最后如果 cmp 的返回值大于0，就表示这两段地址对应的元素就需要交换位置，为了代码的好看和可读性，将需交换两元素的功能封装成一个函数。该函数只需要这两元素地址，和元素大小即可，因为我们不知道用户传入的数据类型，而 size 知道这个数据类型的大小(字节)，因此交换两元素我们可以写成一个字节一个字节的交换，这样即满足了泛用性又满足了交换两元素内容

这样我们就完成了模拟实现 qsort 函数的代码，以下就是完整代码，我们可以验证一下功能

#include <stdio.h>

int int_cmp(void* p1, void* p2)
{
	return (*(int*)p1) - (*(int*)p2);
}


//交换两元素内容
void Swap(char* p1, char* p2, size_t size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = 0;
		tmp = *p1;
		*p1 = *p2;
		*p2 = tmp;

		p1++;
		p2++;
	}
}


void my_qsort(void* bass, size_t count, size_t size, int(*cmp)(void* p1, void* p2))
{
	int i = 0;

	for (i = 0; i < count - 1; i++)
	{
		int j = 0;

		for (j = 0; j < count - 1 - i; j++)
		{
			if (cmp((char*)bass + j * size, ((char*)bass + (j + 1) * size)) > 0)
			{
				Swap((char*)bass + j * size, ((char*)bass + (j + 1) * size), size);
			}
		}
	}
}


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

	my_qsort(arr, sz, sizeof(int), int_cmp);

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

	return 0;
}

运行结果：

---

总结

        以上就是本文的全部内容，希望对大家有所帮助，有什么问题评论区提出，感谢大家的支持，我也会更加努力的