C语言--指针（4）

一·函数指针数组

1.格式：
int (*pfarr[10])(int ,int )={Add,Sub,Mul,Div};
形式跟函数指针类似，先写数组类型int ( * )(int ,int ),再在( *) 中添加数组名和元素数

二·回调函数

1.概念：
回调函数就是⼀个通过函数指针调⽤的函数。
如果你把函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被⽤来调⽤其所指向的函数时，被调⽤的函数就是回调函数。回调函数不是由该函数的实现⽅直接调⽤，⽽是在特定的事件或条件发⽣时由另外的⼀⽅调⽤的，⽤于对该事件或条件进⾏响应。
2.实例：

#include <stdio.h>
void menu()
{
	printf("******************************\n");
	printf("****  1. add     2. sub   ****\n");
	printf("****  3. mul     4. div   ****\n");
	printf("****  0. exit             ****\n");
	printf("******************************\n");
}

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


int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	do
	{
		menu();
		printf("请选择:");
		scanf_s("%d", &input);
		switch (input)
		{
		case 1:
			printf("请输入两个操作数:");
			scanf_s("%d %d", &x, &y);
			ret = Add(x, y);
			printf("%d\n", ret);
			break;
		case 2:
			printf("请输入两个操作数:");
			scanf_s("%d %d", &x, &y);
			ret = Sub(x, y);
			printf("%d\n", ret);
			break;
		case 3:
			printf("请输入两个操作数:");
			scanf_s("%d %d", &x, &y);
			ret = Mul(x, y);
			printf("%d\n", ret);
			break;
		case 4:
			printf("请输入两个操作数:");
			scanf_s("%d %d", &x, &y);
			ret = Div(x, y);
			printf("%d\n", ret);
			break;
		case 0:
			printf("退出计算器\n");
			break;
		default:
			printf("选择错误，重新选择\n");
			break;
		}
	} while (input);
	return 0;
}

用VS写一段函数，实现一个计算器。
如图1，使用switch语句，随着计算器功能的增加，case也在增加，而每一段case语句中都有很多相似的代码，显得冗余。
这时，如果把这些调用的函数都放在一个数组中，随调随用就会省事很多。

#include <stdio.h>
void menu()
{
	printf("******************************\n");
	printf("****  1. add     2. sub   ****\n");
	printf("****  3. mul     4. div   ****\n");
	printf("****  0. exit             ****\n");
	printf("******************************\n");
}

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;
}
int main() {
	menu();
	printf("请输入：");
	int (*pfarr[])(int, int) = { NULL,Add,Sub,Mul,Div };
	                               0   1   2   3   4
	int i = 0;
	int sz = sizeof(pfarr) / sizeof(pfarr[0]);
	int n = 0;
	scanf_s("%d", &n);
	if (n == 0)
	{
		printf("退出计算器");
	}
	else if (n >= 1 && n <= 4)
	{
		printf("输入两个操作数：");
		int x = 0, y = 0;
		scanf_s("%d %d", &x, &y);
		int ret = pfarr[n](x, y);
		printf("%d\n", ret);
	}
	return 0;
}

这样就简化了，当输入的为1~4的数字，则调用对应函数。
如果用回调函数，则还有一种写法：

#include <stdio.h>
void menu()
{
	printf("******************************\n");
	printf("****  1. add     2. sub   ****\n");
	printf("****  3. mul     4. div   ****\n");
	printf("****  0. exit             ****\n");
	printf("******************************\n");
}

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))//形参是函数指针
{
	printf("输入两个操作数：");
	int x = 0, y = 0;
	scanf_s("%d %d", &x, &y);
	int ret = pf(x, y);//函数指针可以直接调用
	printf("%d\n", ret);
}
int main() {
	int n = 0;
	do {
		menu();
		printf("请输入：");
		
		scanf_s("%d", &n);
		switch (n)
		{
		case 1:
			calc(Add);
			break;
		case 2:
			calc(Sub);
			break;
		case 3:
			calc(Mul);
			break;
		case 4:
			calc(Div);
			break;
		case 0:
			printf("退出计算器");
		default:
			printf("请重新选择");

		}
	} while (n);
	

	return 0;
}

三·qsort（）

base:数组首元素地址
num:元素个数
size:每个元素大小
compar：函数地址，该函数用来比较两个元素，需要自己写出

四·qsort排序

之前的冒泡排序只能排序整型元素，其它类型的不能，而qsort可以实现任意数据的排序。
1.整型数组元素升序排列。

2.对结构体元素排序

五·使用回调函数，模拟实现qsort（冒泡的方式）

改造：把有差异的地方抽出来，再调用函数单独传进去。

int cmp_int(const void* p1, const void* p2)//写个函数，用来比较两个整型元素大小
{
	return *(int*)p1 - *(int*)p2;
}
void swap(char* buf1, char* buf2, size_t width)//一个字节一个字节转换
{
	int a = 0;
	for (a = 0; a < width; a++)
	{
		char tep = *buf1;
		*buf1 = *buf2;
		*buf2 = tep;
		buf1++;
		buf2++;
	}
}
void Print_arr(int arr[], size_t sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
void bobble_sort2(void* base, size_t sz, size_t width, int(*cmp)(const void* p1, const void* p2))
//修改后的冒泡排序，模拟qsort
//接收函数地址的是函数指针
{
	int i = 0,j=0;
	for (i = 0; i < sz - 1; i++)//趟数和每趟里比较的不变
	{
		for (j = 0; j < sz - 1 - i; j++)
		{
		//因为void*不能解引用，所以要将首元素地址强制类型转换，转换为char*最方便，因为char占一个字节，
		//要想找到arr[j]，只需再+j*width（每个元素大小）就行了
			if (cmp((char*)base+j*width,(char*)base+(j+1)*width) > 0) {
			//如果不符合顺序，那就调用swap函数换一下顺序
				swap((char*)base + j * width, (char*)base + (j + 1) * width,width);
			}
		}
	}
}
void test1()//“主函数”，将整型数组排序
{
	int arr[] = { 2,3,8,6,4,9,5,7,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bobble_sort2(arr, sz, sizeof(arr[0]), cmp_int);//调用冒泡排序2
	Print_arr(arr,sz);//打印数组
}
int main() {
	test1();
	return 0;
}

排序结构体大小：

#include <stdio.h>
#include <string.h>
struct stu {
	char name[20];
	int age;
};
void swap(char* buf1, char* buf2, size_t width)
{
	int z = 0;
	for (z = 0; z < width; z++) {
		char tep = *buf1;
		*buf1 = *buf2;
		*buf2 = tep;

	}

}
int cmp_struct_by_name(const void* p1, const void* p2)
{
	return strcmp(((struct stu*)p1)->name,((struct stu*)p2)->name);
	//结构体比较不能用“-”，而要用库函数strcmp，别忘了包含头文件#include <string.h>
}
void bubble2_sort(void* base, size_t sz, size_t width, int(*cmp)(const void* p1, const void* p2)) {
	int i = 0,j=0;
	for (i = 0; i < sz - 1; i++) {
		for (j = 0; j < sz - 1 - j; j++) {
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
				swap((char*)base + j * width, (char*)base + (j + 1) * width,width);
		}
	}
}
int main() {
	struct stu arr[] = { {"danika",18},{"jack",20},{"dianna",28} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble2_sort(arr, sz, sizeof(arr[0]), cmp_struct_by_name);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%s %d\n", arr[i].name, arr[i].age);
	}
	return 0;
}

补充strcmp函数：


依次比较对应字母的ASCII值，若一样则往后一位比较