【C语言进阶9——指针的进阶（6）- 回调函数】

---

前言

本文讲学习指针进阶的最后一点内容：回调函数。

---

1、回调函数是什么？

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，这就是是回调函数。

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

2、回调函数的应用举例

下面将通过两个例子来说明回调函数的应用。

2.1 举例1—简易计算器

在前两篇博文中，都使用了简易计算器这个代码作为例子，用到了不同的指针知识点：

• 【C语言进阶5——指针的进阶（2）】6、函数指针数组
• 【C语言进阶6——指针的进阶（3）- 总结数组和指针】7.3 指向函数指针数组的指针的应用

在这里将再次使用简易计算器这个例子，使用回调函数来写代码，简易计算器前后用了四种方式来举例学习知识点，前后都是连贯的：

回调函数举例1， 简易加法器
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");
}

void calc(int (*pf)(int,int))
{
	int x = 0;
	int y = 0;
	int ret = 0;

	printf("请输入2个操作数:>");
	scanf("%d%d", &x, &y);
	ret = pf(x, y);
	printf("ret = %d\n", ret);
}

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

2.2 举例2—库函数 qsort 的模拟实现

这里将从冒泡排序引出库函数qsort的模拟实现，会使用到回调函数。

2.2.1 冒泡排序法

冒泡排序在前文中写过了：【C语言基础5——数组（1）】4、数组作为函数参数
这里再次拿来使用，当作回调函数的例子：

void bubble_sort(int* arr, int sz)
{
	//排序坐外面的大循环次数
	int i = 0;
	for ( i = 0; i < sz-1; i++)
	{
		int flag = 1;//状态机标志位，代表数组本身元素就是从小到大排序的
		int j = 0;
		for ( j = 0; j < sz-1-i; j++)
		{
			if (arr[j]>arr[j+1])
			{
				flag = 0;//只要有一个地方需要排序，就置零
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
		if (1==flag)
		{//第一轮排序结果都是1，说明没有地方需要排序
			break;//直接跳出后面的循环，不需要再排序了
		}
	}
}
int main()
{
	//int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr[] = { 3,1,2,4,5,6,8,9,7,10 };
	//写一个冒泡排序的函数，
	//arr表示首元素的地址， &arr[0],也是首元素的地址
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	int i = 0;
	for ( i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

2.2.2 使用库函数 qsort 排序

qsort是库函数，对排序类型没有限制：整形、浮点、字符串都可以

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

void print_a(int * a, int sz)
{
	for (int j = 0; j < sz; j++)
	{
		printf("%d ", a[j]);
	}
}
int cmp(void* p1, void* p2)
{
	/*if (*(int*)p1-*(int*)p2)
	{
		return 1;
	}
	else if (*(int*)p1 == *(int*)p2)
	{
		return 0;
	}
	else
	{
		return -1;
	}*/
	return (*(int*)p1 - *(int*)p2);//解引用后，数值大小进行比较
}
int main()
{
	int a[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(a) / sizeof(a[0]);
	qsort(a, sz,sizeof(a[0]),cmp);
	print_a(a, sz);
	return 0;
}

2.2.3 自定义函数 bubble_sort 模拟实现库函数 qsort

下面是基于冒泡排序来实现模拟实现库函数 qsort：

• 改进冒泡排序函数 bubble_sort，改进了参数
• 使用了回调函数，函数地址作为参数传到函数 bubble_sort
• void* p1 可以接收任意类型的数据，没有限制 p1访问数据的类型
• 这种方法的好处是，排序的类型没有限制，还可以对字符串进行排序

int cmp(void* p1, void* p2)
{
	//强制转换成整形指针，解引用访问4个字节
	return (*(int*)p1 - *(int*)p2);//指针指向的空间内容大小进行比较
}

void swap(char* p1, char* p2, int num)
{
	for (int i = 0; i < num; i++)//赋值4个字节，完整一个整形数的交换
	{
		char tmp = *p1;//按字节操作，每个字节都按顺序复制
		*p1 = *p2;
		*p2 = tmp;
		p1++;
		p2++;
	}
}
		// 数组首元素的地址  元数个数   每个元素的占字节数  函数指针，调用函数 传入函数参数
void bubble_sort(void* base,int sz,int cnt, int(*cmp)(const void* p1, const void* p2))
{
	for (int  i = 0; i < sz-1; i++)
	{
		for (int j = 0; j < sz-1-i; j++)
		{
			if (cmp((char*)base+j*cnt, (char*)base+(j+1)*cnt)>0)//前面大于后面，交换
			{
				swap((char*)base + j * cnt, (char*)base + (j + 1)*cnt, cnt);
			}
		}
	}
}
void print_a(int * a, int sz)
{
	for (int j = 0; j < sz; j++)
	{
		printf("%d ", a[j]);
	}
}
int main()
{
	int a[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(a) / sizeof(a[0]);
	bubble_sort(a, sz,sizeof(a[0]),cmp);//模拟实现库函数排序
	print_a(a, sz);//打印函数
	return 0;
}

这里要注意几个地方，按照字节访问内存中的数据：

1、 cmp((char*)base+j*cnt, (char*)base+(j+1)*cnt)

• base 是char* 类型，访问数据只占1个字节，base+4 移动4个字节，移动到下一个整形的地址
  
  2、swap((char*)base + j * cnt, (char*)base + (j + 1)*cnt, cnt)
• int 类型数值在内存中存储占 4 个字节
• 定义char* base就可以字节来访问整形数据，每个字节都可以交换，按顺序交换4个字节，完成一个整形的交换
• 字节是内存中最小的单位，按字节访问数据，就可以操作任何类型的数据
• 这种方式要牢记

2.2.4 自定义函数 bubble_sort 对结构体成员排序

• 对结构体成员的名字排序
• 对结构体成员的名字排序

struct stu
{
	char name[20];
	int age;
	double score;
};
void swap(char* p1, char* p2, int num)
{
	for (int i = 0; i < num; i++)//赋值4个字节，完整一个整形数的交换
	{
		char tmp = *p1;//按字节操作，每个字节都按顺序交换
		*p1 = *p2;
		*p2 = tmp;
		p1++;
		p2++;
	}
}
对结构体成员的年龄排序
int cmp_stu_age(const void* p1, const void* p2)
{
	return ((struct stu*)p1)->age - ((struct stu*)p2)->age;//整数比较，这里面要自己写
}
对结构体成员的名字排序
int cmp_stu_name(const void* p1, const void* p2)
{
	return strcmp( ((struct stu*)p1)->name , ((struct stu*)p2)->name );//比较字符串长度，这里面要自己写
}

// 数组首元素的地址  元数个数   每个元素的占字节数  函数指针，调用函数 传入函数参数
void bubble_sort(void* base, int sz, int cnt, int(*cmp)(const void* p1, const void* p2))
{
	for (int i = 0; i < sz - 1; i++)
	{
		for (int j = 0; j < sz - 1 - i; j++)
		{
			if (cmp((char*)base + j * cnt, (char*)base + (j + 1)*cnt) > 0)//前面大于后面，交换
			{
				swap((char*)base + j * cnt, (char*)base + (j + 1)*cnt, cnt);
			}
		}
	}
}
void print_a(struct stu* a, int sz)
{
	for (int j = 0; j < sz; j++)
	{
		printf("%s %d %lf \n", a[j].name,a[j].age,a[j].score);
	}
}
int main()
{
	struct stu a[3] = { {"zhangsan",20,65.5},{"lisi",30,78.8},{"wangwu",25,89.5} };	
	int sz = sizeof(a) / sizeof(a[0]);
	//bubble_sort(a, sz, sizeof(a[0]), cmp_stu_age);//按年龄排序
	bubble_sort(a, sz, sizeof(a[0]), cmp_stu_name);//按名字排序
	print_a(a, sz);
	return 0;
}

对不同类型的数据排序时，整个代码只有函数 cm p相关的内容要自己写，其他函数都可以直接使用。

运行结果见下图：

---

总结

指针进阶的学习内容就告一段落了，这块花了很长时间去巩固复习，但是感觉自己做题的能力还是有待提高，还是需要需要多练习。

要掌握两个地方：

• void* p1可以接收任意类型的数据，没有限制 p1访问数据的类型
• 按字节访问数据的函数写法

下一篇开始学习字符串函数相关的内容了。