【C语言学习笔记---指针进阶02】

C语言进阶之回调函数

前言：
通过C语言进阶前篇的指针进阶01的知识，继续学习。这篇引用一个简易计算器的程序进行深入学习指针进阶的知识。

/知识点汇总/

1、函数指针数组

比如：指针数组

char* arr[5];//字符指针数组 --- 数组 -- 存放的是字符指针
int* arr2[5];//整型指针数组 -- 数组 -- 存放的是整型指针

那么函数指针数组 – 是数组 – 存放的是函数指针 – 函数指针变量存放的是函数的地址
引入简易计算器程序理解分析：

#include 

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 x = 0;
	int y = 0;
	int ret = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			printf("请输入2个操作数：");
			scanf("%d %d", &x, &y);
			ret = Add(x, y);
			printf("ret = %d\n", ret);
			break;
		case 2:
			printf("请输入2个操作数：");
			scanf("%d %d", &x, &y);
			ret = Sub(x, y);
			printf("ret = %d\n", ret);
			break;
		case 3:
			printf("请输入2个操作数：");
			scanf("%d %d", &x, &y);
			ret = Mul(x, y);
			printf("ret = %d\n", ret);
			break;
		case 4:
			printf("请输入2个操作数：");
			scanf("%d %d", &x, &y);
			ret = Div(x, y);
			printf("ret = %d\n", ret);
			break;
		case 0:
			printf("退出程序\n");
			break;
		default:
			printf("输入错误，请重新输入\n");
			break;
		}

	} while (input);
	return 0;
}

发现上面的代码，较冗余，可扩展性差；又发现各个函数除了函数名与函数体不同，函数参数类型，和返回值类型均相同

所以引入函数指针数组的引用对代码进行优化：
(前提是函数参数类型，和返回值类型均相同)

#include 

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 x = 0;
	int y = 0;
	int ret = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		//函数指针数组
		//int (*pfarr[4])(int, int) = { Add,Sub,Mul,Div };
		//数字下标不对应：             0    1   2   3
		//优化让其与菜单对齐：
		int (*pfarr[5])(int, int) = { NULL,Add,Sub,Mul,Div };
		if (0 == input)
			printf("退出程序\n");
		else if (input >= 1 && input <= 4)
		{
			printf("请输入两个操作数：");
			scanf("%d %d", &x, &y);
			ret = pfarr[input](x, y);
			printf("ret = %d\n", ret);
		}
		else
			printf("输入错误，请重新输入\n");
	} while (input);
	return 0;
}

但是此时的代码还是显得有些复杂，那么继续深入，引用回调函数？

2、回调函数

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

然后接着上面的引子。继续优化建议计算器的代码，引入回调函数思想：

#include 

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 (*p)(int, int))
{
	int x = 0;
	int y = 0;
	int ret = 0;
	printf("请输入2个操作数：");
	scanf("%d %d", &x, &y);
	ret = p(x, y);
	printf("ret = %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;
	int x = 0;
	int y = 0;
	int ret = 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;
}

3、 回调函数的应用 — qsort库函数

qosrt函数的介绍：底层使用的快速排序的方式，是实现对数据进行排序的；可直接调用qsort库函数，并且可用来对排序任意类型的数据.

//对数据的排序有很多种方法：
//冒泡排序
//选择排序
//插入排序
//快速排序
//…
//那么qsort函数具体怎么使用呢？

这里引用经典的冒泡排序来学习，首先回顾冒泡排序的思想：两两相邻的元素进行比较排序

#include 
void bubble_sort(int* arr, int sz)
{
	int i = 0;
	int j = 0;
	//趟数 -- 趟数等于sz - 1,比如10个元素只需要执行9趟
	for (i = 0; i < sz - 1; i++) 
	{
		for (j = 0; j < sz - 1 - i; j++)//剩余比较的对数
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
			}
		}
	}
}
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[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	print(arr, sz);
	bubble_sort(arr, sz);//冒泡排序
	print(arr, sz);
	return 0;
}

通过冒泡排序得知，只局限于排序整型的数据；那么如果我想排序浮点数或者字符串呢？
所以引出qsort库函数，来兼容任意类型的排序，这里以结构体类型为例。

qsort函数
原型：void qsort( void *base, size_t num, size_t width, int (__cdecl *compare )(const void *elem1, const void elem2 ) );
头文件：
//参数1：base 待排序数组的起始地址
//参数2：num待排序数组元素的个数
//参数3：待排序数组元素类型的大小，单位字节,sizeof(arr[0])
//参数4：是一个函数指针类型,compare指向了一个函数，该函数的参数类型是void任意类型的数据，返回值类型是函数指针类型，其次compare该函数实现的功能是比较相邻元素e1、e2的大小，e1和e2中存放的是需要比较的两个元素的地址。

补充：
void* 指针类型的作用：
void* 类型的指针，是无具体类型的指针，本质是方便用来存放任意类型的地址，和转换需要类型的功能
所以qsort函数的思想运用了回调函数的思想：
因为void类型与我们此时需要比较的数组元素类型不同，则需要用强制类型转换,使得数据类型达成一致
其次，void 类型的指针 – 不能进行解引用操作符，也不能进行±整数的操作，所以也证明了想要取数组的元素地址，需要使用强制类型转换。

compar函数的比较含义：
1.排序整形数组时，两个整型可直接使用>比较
2.排序结构体数组时，两个结构体的数据不能直接使用>比较，也就是不同类型的数据比较方式，也会不同。
该compar函数的返回值类型规定：
当e1指向的元素 > e2指向的元素时，返回一个大于0的数字
当e1指向的元素 = e2指向的元素时，返回一个等于0的数字
当e1指向的元素 < e2指向的元素时，返回一个小于0的数字
简述：cmp_int()功能就是写比较两个被指向的元素大小即可

#include 
#include  //调用qsort函数需声明的头文件
#include  //调用strcmp函数需声明的头文件

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

//因为void*类型与我们此时需要比较的数组元素类型不同，则需要用强制类型转换,使得数据类型达成一致
//其次，void* 类型的指针 -- 不能进行解引用操作符，也不能进行+-整数的操作，所以也证明了想要取数组的元素地址，需要使用强制类型转换
int cmp_int(const void* e1,const void* e2)
{
	return *(int*)e1 - *(int*)e2;
}
//该函数的返回值类型规定：
//当e1指向的元素 > e2指向的元素时，返回一个大于0的数字
//当e1指向的元素 = e2指向的元素时，返回一个等于0的数字
//当e1指向的元素 < e2指向的元素时，返回一个小于0的数字
//简述：cmp_int()功能就是写比较两个被指向的元素大小即可

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

//定义结构体类型
struct Stu
{
	char name[20];
	int age;
};
//结构体数据该如何比较排序呢？根据结构体参数来看：
//1.根据年龄比较
//2.根据名字比较
int cmp_stu_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}

int cmp_stu_by_name(const void* e1, const void* e2)
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}

void print_struct(struct Stu* arr,int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("name = %s ,age = %d\n", arr[i].name, arr[i].age);
	}
	printf("\n");
}

void test2() 
{
	struct Stu arr[3] = { {"zhangsan",20},{"lisi",30},{"wangwu",12} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	print_struct(arr, sz);
	qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);//快速排序
	print_struct(arr, sz);
}

void test3()
{
	struct Stu arr[3] = { {"zhangsan",20},{"lisi",30},{"wangwu",12} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	print_struct(arr, sz);
	qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);//快速排序
	print_struct(arr, sz);
}

int main()
{
	//test1();//排序整型数据
	//test2();//排序结构体数据类型 -- 以年龄age排序
	test3();//排序结构体数据类型 -- 以姓名name排序
	return 0;
}

小结：
使用qsort我们需要明白其参数的含义，根据需要排序的数据类型进行，填参数并且重要的是用户根据需要自己完善compar函数的比较是必须的。
所以只要掌握了qsort函数就能对任意类型的数据进行排序了。

4、模拟qsort函数

使用冒泡排序的算法，模拟实现一个排序函数，并且可以兼容任意类型的数据
bubble_sort();
整型数据/字符数据/结构体数据…

void bubble_sort(void* base, size_t num, size_t size, int (*cmp)(const void* e1, const void* e2))
{
	//冒泡排序的趟数
	int i = 0;
	int j = 0;
	for (i = 0; i < num - 1; i++)
	{
		//一趟冒泡排序
		for (j = 0; j < num - 1 - i; j++)
		{
			//括起来的核心部分，不同需改造，外面的循环部分是相同的，不做更改
			//
			//if (arr[j] > arr[j + 1])
			//{
			//	int temp = arr[j];
			//	arr[j] = arr[j + 1];
			//	arr[j + 1] = temp;
			//}
			//
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				//交换 --- 拆分为每一位的字节交换 --- size/char = size
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

解释说明：
发现正题架构依然采用的冒泡排序的思路，简单的说就是完善了兼容任意的数据类型排序；
那么具体代码是如何实现的呢？然后我们模拟qsort函数，至于函数的参数参看qsort技术文档就能明白，
void* base 就是表示待排序的第一个元素地址，那么设计一个满足任意类型的函数排序，所以需要用void接收地址，其他的void也同理；然后，第二个参数num，也就是待排序的个数；第三个参数size，指的就是待排序的元素，其字节的大小，通常以sizeof(arr[0])计算所得；最后一个参数，是我们前面所学的函数指针，指针指向的cmp函数功能完成两个元素的比较，但这个函数是用户自己需要写，因为只有用户在知道使用这个函数去对什么类型的数据排序。
然后明白了参数的设置，跳过熟知的冒泡排序的外围框架，直接来到该函数的内核部分，我们明白冒泡排序的思想，是比较相邻的两个元素大小，然后排序；同理，要想实现任意类型的元素大小比较，我们就需要思考如何像冒泡int整型数据一样比较大小，交换位置呢？
探究，int是4个字节，然后进行比较就是4个字节4个字节的进行比较，
比如：4，3比较，以升序排为例
以十六进制表示为：
0x00 00 00 04 ---- 4
0x00 00 00 03 ---- 3
比较发现 4 > 3，交换4和3的位置，直接是4个字节进行交换即可；
这里我们就明白了，交换的关键点就是字节的方式进行操作，那么我们就可以以void类型强转为(char*)类型，
那么就可以用base起始地址加宽度也就是偏移相应的字节，进行操作。最后同样以一个字节类型进入swap进行交换即。

现在完整的模拟实现qsort函数，代码如下所示：

#include 
//#include 
#include 
struct Stu
{
	char name[20];
	int age;
};
void print(int* arr, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
void print_struct(struct Stu* arr, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%s %d\n", arr[i].name, arr[i].age);
	}
	printf("\n");
}

void swap(char* buf1, char* buf2, size_t size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char temp = *buf1;
		*buf1 = *buf2;
		*buf2 = temp;
		buf1++;
		buf2++;
	}
}
void bubble_sort(void* base, size_t num,size_t size,int (*cmp)(const void* e1,const void* e2))
{
	//冒泡排序的趟数
	int i = 0;
	int j = 0;
	for (i = 0; i < num - 1; i++)
	{
		//一趟冒泡排序
		for (j = 0; j < num - 1 - i; j++)
		{
			//if (arr[j] > arr[j + 1])
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				//交换 --- 拆分为每一位的字节交换 --- size/char = size
				swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

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]);
	//bubble_sort(arr, sz);
	print(arr, sz);
	//模拟实现整型排序
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
	print(arr, sz);
}

int cmp_by_age(const void* e1,const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}
void test2()
{
	struct Stu arr[] = { {"zhangsan",20},{"lisi",30},{"wangwu",15} };
	int sz = sizeof(arr) / sizeof(arr[0]);//3
	print_struct(arr, sz);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_by_age);
	print_struct(arr, sz);
}

int cmp_by_name(const void* e1, const void* e2)
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
void test3()
{
	struct Stu arr[] = { {"zhangsan",20},{"lisi",30},{"wangwu",15} };
	int sz = sizeof(arr) / sizeof(arr[0]);//3
	print_struct(arr, sz);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_by_name);
	print_struct(arr, sz);
}

int main()
{
	test1();//模拟排序整型数据
	//test2();//模拟排序结构体 -- 以年龄
	//test3();//模拟排序结构体 -- 以姓名
	return 0;
}

5、结语

半亩方糖一鉴开，天光云影共徘徊。
问渠哪得清如许?为有源头活水来。–朱熹（观书有感）