【C语言指针超详解(五)】--回调函数，qsort函数的理解和使用，qsort函数的模拟实现

草莓熊Lotso

于 2025-05-13 09:10:14 发布

阅读量1.1k

点赞数 38

分类专栏： C语言文章标签： c语言开发语言笔记经验分享其他

本文链接：https://blog.csdn.net/2503_91389547/article/details/147872802

版权

C语言专栏收录该内容

19 篇文章

订阅专栏

🔥个人主页：@草莓熊Lotso的个人主页

🎬作者简介：C++研发方向学习者

📖个人专栏：《C语言》

⭐️人生格言：生活是默默的坚持，毅力是永久的享受。

一.回调函数

1.1--回调函数的概念

--回调函数就是一个通过函数指针调用函数。

如果你把函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被用来调用其所指向的函数

时，被调用的函数就是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

实际举例：

int Add(int x, int y)//这里的Add就是回调函数
{
	return x + y;
}

void test(int(*pf)(int, int))
{
	int r = pf(10, 20);
	printf("%d\n", r);
}

int main()
{
	test(Add);
	return 0;
}

1.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 calc(int(*pa)(int, int))
{
	int ret = 0;
	int x = 0;
	int y = 0;
	printf("即将进行运算，请输入操作数：");
	scanf("%d %d", &x, &y);
	ret = pa(x, y);
	printf("%d\n", ret);
}

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

我们可以把调用的函数的地址以参数形式传递过去，使用函数指针接收，函数指针指向什么函数就调用什么函数，这里其实使用的就是回调函数的功能。

二.qsort函数的理解和使用

2.1--qsort函数的理解

--qsort函数是C语言中提供的一个排序函数(quick sort)，是基于快速排序算法思想的一种排序算法。

qsort函数的优点：

现成的排序算法，学会了直接就可以使用，不需要自己实现了
大部分的情况下效率都是比冒泡排序高的
qsort函数可以排序任意类型的数据

qsort函数的原型及其参数解析：

头文件 #include<stdlib.h>;

void qsort(void *base, size_t num, size_t size, int (*compar)(const void *, const void *));

参数说明：

void *base：指向要排序的数组首元素的指针。由于是 void * 类型，所以可以处理任意类型的数组。
size_t num：数组中元素的个数。size_t 是一种无符号整数类型，通常用于表示大小或计数。
size_t size：每个数组元素的大小（以字节为单位）。这里有这个参数是因为，前面用的void*类型，只知道元素个数不知道每个元素多大是不行的。
int (*compar)(const void *, const void *)：一个指向比较函数的指针。该比较函数用于比较数组中的两个元素，它接受两个 const void * 类型的参数，返回值为 int 类型：

如果进行升序排序，返回一个正整数。
如果两个元素相等，返回0。
如果进行降序排序，返回一个负整数。

补充说明一下：默认第一个参数比第二个大；还有strcmp比较字符串的大小刚好和这里的比较函数的返回正负可以直接对上,在后面的使用中都会体现出来的。

2.2--使用qsort函数排序整型数据

--我们试着用qsort函数排序一下整型数据把(注意看注释)

#include<stdio.h>
#include<stdlib.h>
//qsort函数的使用者需要实现一个比较函数
//升序
int cmp_int1(const void* p1, const void* p2)
{
	return (*(int*)p1) - (*(int*)p2);//因为p1默认更大，所以p1在前减肯定返回正整数
    //void*类型无法直接进行指针运算，故强制类型转换为所需类型再进行运算
}
//降序
int cmp_int2(const void* p1, const void* p2)
{
	return (*(int*)p2) - (*(int*)p1);因为p2默认更小，所以p2在前减肯定返回负整数
}
void print(int arr[], int sz)
{
	int i = 0;
	for (i = 0;i < sz;i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
int main()
{
	int arr[] = { 0,1,3,5,2,4,6,8,7,9 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	printf("排序前：");
	print(arr, sz);
	qsort(arr, sz, sizeof(arr[0]), cmp_int1);
	printf("升序排序后：");
	print(arr, sz);
	qsort(arr, sz, sizeof(arr[0]), cmp_int2);
	printf("降序排序后：");
	print(arr, sz);
}

2.3--使用qsort函数排序结构数据

--我们再试试其它类型把，拿结构数据试试(注意看注释)

///结构体：年龄和名字一个按降序排，一个按升序排
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct mov
{
	char name[30];
	int age;
};

//按年龄升序排
int cmp_byage(const void* p1, const void* p2)
{
	//return (*(struct mov*)p1).age - (*(struct mov*)p2).age;
	return (((struct mov*)p1)->age - ((struct mov*)p2)->age);
//上述两种形式都可以，一个不用解引用，一个需要,这里的—>操作符可以自行去了解一下
}
//按名字降序排
int cmp_byname(const void* p1, const void* p2)//名字是字符串所以需要用strcmp比较
{
	return strcmp(((struct mov*)p2)->name, ((struct mov*)p1)->name);
//p1默认比较大，按strcmp函数的比较规则，这里会返回负整数，刚好符合降序
}

void print(struct mov arr[], int sz)
{
	int i = 0;
	for (i = 0;i < sz;i++)
	{
		printf("%s：%d\n", arr[i].name,arr[i].age);
	}
	printf("\n");
}
int main()
{
	struct mov arr[] = { {"zhangsan",20},{"lisi",18},{"wangwu",19} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	printf("排序前：");
	print(arr, sz);
	qsort(arr, sz, sizeof(arr[0]), cmp_byage);
	printf("按年龄升序排序后：");
	print(arr, sz);
	qsort(arr, sz, sizeof(arr[0]), cmp_byname);
	printf("按名字降序排序后：");
	print(arr, sz);
}

补充知识点

strcmp比较规则：

从两个字符串的首字符开始，逐个字符地进行比较，直到遇到不同的字符或者到达字符串的结束符'\0'。比较时，依据字符的ASCII码值来判断大小。

如果两个字符串完全相同，即对应位置的字符都相等，直到两个字符串都结束，则strcmp返回0。
如果在比较过程中，遇到第一个不相等的字符，且第一个字符串中该字符的ASCII码值大于第二个字符串中对应字符的ASCII码值，strcmp返回一个正整数。
如果在比较过程中，遇到第一个不相等的字符，且第一个字符串中该字符的ASCII码值小于第二个字符串中对应字符的ASCII码值，strcmp返回一个负整数。

三.qsort函数的模拟实现

--使用回调函数，模拟实现qsort(采用冒泡排序的方式)，代码中还采用了void*类型，体会其用法。

#include<stdio.h>

int int_cmp(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);
}
void swap(char* p1, char* p2, int width)
{
	int i = 0;
	for (i = 0;i < width;i++)//虽然不知道每个元素的大小具体是多少，但是可以一个一个字节的交换，小于width就行
	{
		char temp = *(p1 + i);
		*(p1 + i) = *(p2 + i);
		*(p2 + i) = temp;
	}
}
void bubble_sort(void* base, int sz, int width, int(*cmp)(void*, void*))
{
	int i = 0;
	for (i = 0;i < sz;i++)
	{
		int j = 0;
		for (j = 0;j < sz - 1 - i;j++)
		{
			//虽然不知道具体元素类型，但是强制转换为char*类型是因为是它的大小是1，再+j*size就可以找到第j个元素了
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width)>0)
			{
				swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
} 
void print(int arr[], int sz)
{
	int i = 0;
	for (i = 0;i < sz;i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
int main()
{
	int arr[] = { 0,1,2,3,4,6,8,7,5,9};
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), int_cmp);
	print(arr, sz);
}

画图分析一下过程，这里int_cmp函数就是回调函数：