【15 深入理解指针 (4)】

目录

1. 回调函数是什么
2. qsort使用举例
3. qsort函数模拟实现

---

1. 回调函数是什么

回调函数是一个通过函数指针调用的函数
如果把函数的指针作为参数,这个指针调用的所指向的函数,就是回调函数。回调函数不是实现方主动调用，而是由参数方在特定的条件下调用，用于对该事件或条件响应
上一章刚开始写的计算器功能有很多冗余的代码，我们可以使用回调函数来简化，用一个函数来统一加减乘除四种运算，通过函数指针调用回调函数来实现功能

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>

int add(int a, int b) {
	return a + b;
}
int sub(int a, int b) {
	return a - b;
}
int mul(int a, int b) {
	return a * b;
}
int div(int a, int b) {
	return a / b;
}

void calc(int (*pf)(int,int)) {

	int n1, n2;
	int ret = 0;
	printf("请输入两个数\r\n");
	scanf("%d %d", &n1, &n2);
	ret = pf(n1, n2);
	printf("ret=%d\r\n", ret);
}
void menu() {
	printf("********************\r\n");
	printf("*** 1.add  2.sub ***\r\n");
	printf("*** 3.mul  4.div ***\r\n");
	printf("*** 0.退出       ***\r\n");
	printf("********************\r\n");
}
int main()
{
	int input = 1;
	do
	{
		menu();
		printf("请选择功能\r\n");
		scanf("%d", &input);
		switch (input)
		{
		case 0:
			//退出
			printf("退出游戏\r\n");
			break;
		case 1:
			calc(add);
			break;
		case 2:
			calc(sub);
			break;
		case 3:
			calc(mul);
			break;
		case 4:
			calc(div);
			break;
		default:
			printf("输入错误\r\n");
			break;
		}
		
	} while (input);
		
	return 0;
}

2. qsort使用举例

2.1 qsort说明

我们之前写的冒泡排序有个缺陷,只能排序单一类型的数据,当我们规定参数类型为整数时,便只能排序整形数据。有没有可以排序任何类型的函数，这就是qsort函数，先在c官网查看函数定义

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

需要包含头文件 stdlib.h

该函数有4个参数
第一个是void*类型的数据,因为不确定数据的类型,所以用一个void类型,void类型可以转换为其他类型
num是数组的长度,有几个元素
size是每个元素的大小,如int是4字节,决定了每次越过一个数据的大小
最后一个是函数指针,需要自己实现回调函数

函数的返回值说明,小于0第一个指针数据小于第二个,等于0相等,大于0第一个数据大于第二个

该函数的实现是快速排序,第一个q是快速的意思

2.2 使用qsort排列整形数据

// int (*compar)(const void*,const void*)
int com(const void* n1,const void* n2) {

	return *(int*)n1 - *(int*)n2; 
}

int ary[10] = {3,1,5,7,9,4,8,2,0,6};
qsort(ary,10,4, com);

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

运行结果:

上面的是升序,降序只需要将return的两个变量交换位置即可

2.3 使用qsort排列结构体数据

//结构体
struct Stu {
	char name[20];
	int age;
};
//按年龄比较
int com2(const void* n1, const void* n2) {

	return ((struct Stu*)n1)->age - ((struct Stu*)n2)->age;
}

//按名字比较
int com3(const void* n1, const void* n2) {

	return strcmp(((struct Stu*)n1)->name, ((struct Stu*)n2)->name); 
}
int main()
{

	struct Stu s[3] = { {"zhangsan",20},{"list",30},{"wangwu",15}};
	qsort(s,3,sizeof(struct Stu),com2);
	for (int i = 0; i < 3; i++)
	{
		printf("%s %d ", s[i].name,s[i].age);
	}
	
	return 0;
}

执行结果:

上面结果是按年龄大小升序排列,其中按名字比较运用了strcmp这个库函数,这个函数是专门用来比较两个字符串的大小,因为字符串是不能用关系符来比较的

strcmp的返回值,小于0,第一个字符串小于第二个,等于0,两个字符相等,大于0,第一个字符串大于第二个。原理是依次比较每个字母的ascii码，直到遇到第一个不同的判断大小，全相同就是相等，和字符串长度没关系

总结：

• qsort确实可以排序任意类型的数据
• qsort使用时需要传递一个函数的地址，这个函数是用来比较待排序的两个数据的大小的，根据参数和返回值要求实现就行

3. qsort函数模拟实现

通过回调函数,模拟实现qsort,qsort使用的是快速排序,这里用刚学过的冒泡排序

功能实现:

//交换两数
void swap(char* p1,char* p2,int len) {

	for (int i = 0; i < len; i++) {
		char temp = *p1;
		*p1++ = *p2;
		*p2++ = temp;

	}
}
//void qsort (void* base, size_t num, size_t size,
//int (*compar)(const void*, const void*));
void bubble_sort(void* base,size_t num,size_t size,
	int (*compar)(const void*,const void*)) {

	//冒泡排序
	for (size_t i = 0; i < num - 1; i++) {
		for (size_t j = 0; j < num - 1 - i; j++) {
			if (compar((char*)base+j*size, (char*)base + (j+1) * size) > 0) {
				//交换
				swap((char*)base + j * size, (char*)base + (j+1) * size,size);
				/*for (int k = 0; k < size; k++) {
					char temp = *(((char*)base + j * size) + k);
					*(((char*)base + j * size) + k) = *(((char*)base + (j + 1) * size) + k);
					*(((char*)base + (j + 1) * size) + k) = temp;
				}*/
			}
		}
	}
}

测试:

//int (*compar)(const void*,const void*)
//排序int
int cmpint(const void* p1,const void* p2) {

	return *(int*)p1 - *(int*)p2;
}

struct Stu {
	char name[20];
	int age;
};
//结构体按age排序
int cmpstu_age(const void* p1, const void* p2) {

	return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}

//结构体按age排序
int cmpstu_name(const void* p1, const void* p2) {

	return strcmp(((struct Stu*)p1)->name ,((struct Stu*)p2)->name);
}

int main()
{
	//排序整形
	int ary[6] = {6,3,2,7,4,1};
	bubble_sort(ary,6,4,cmpint);
	for (int i = 0; i < 6; i++) {
		printf("%d ", ary[i]);
	}
	printf("\r\n");
	//排序结构体
	struct Stu s[3] = { {"zhangsan",25},{"lisi",17},{"liuqing",56}};
	bubble_sort(s, 3, sizeof(struct Stu), cmpstu_age);
	for (int i = 0; i < 3; i++) {
		printf("%s %d\r\n", s[i].name,s[i].age);
	}

	return 0;
}

结果:

• qosrt中的参数按照官网文档中的填写
• 其中比较功能用的是函数指针,根据返回值判断大小,这个比较功能的回调函数需要调用方自己实,如下面的测试里的cmpint和cmpstu_int,由于传入的是void*指针,需要先转换为对应的类型指针然后取值
• 重难点是qosort的交换功能,因为传入的是数组的首地址,并不知道具体类型和类型每个元素的大小,需要根据传入的size类型大小移动指针，单位是字节。首先将无类型指针void转换为char，一个字节一交换，size有几个字节就交换几次，交换第n个元素，需要得到第n个元素的首地址，所以还得加上第几个元素的j*每个元素的大小size，和下一个元素地址内容交换