指针（四）

目录

1. 回调函数是什么

2. qsort 使用举例

 2.1 使用qsort函数排序整型数据

3. qsort 函数的模拟实现

---

1. 回调函数是什么

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

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

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

举上一篇第一种计算器的例子：

红框中的代码只有调用函数的逻辑是有差异的，我们可以将调用的函数的地址以参数的形式传递过去，使用函数指针接收，函数指针指向什么函数就调用什么函数。这里使用的就是回调函数的功能。 

 将这些重复的部分通过一个函数进行简化：

#include 

void menu()
{
	printf("******************************\n");
	printf("**** 1. +      2. -       ****\n");
	printf("**** 3. *      4. /       ****\n");
	printf("**** 0. exit              ****\n");
	printf("******************************\n");
}

int Fun1(int x, int y)
{
	return x + y;
}

int Fun2(int x, int y)
{
	return x - y;
}

int Fun3(int x, int y)
{
	return x * y;
}

int Fun4(int x, int y)
{
	return x / y;
}

void calc(int(*pf)(int, int))
{
	int x = 0;
	int y = 0;
	int ret = 0;
	printf("请输入两个操作数：");
	scanf("%d %d", &x, &y);
	ret = pf(x, y);
	printf("%d\n", ret);
}

int main()
{
	int input = 0;
	do {
		menu();
		printf("请选择：");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			calc(Fun1);
			break;
		case 2:
			calc(Fun2);
			break;
		case 3:
			calc(Fun3);
			break;
		case 4:
			calc(Fun4);
			break;
		case 0:
			printf("退出计算器\n");
			break;
		default:
			printf("输入错误，重新选择\n");
			break;
		}
	} while (input);
	return 0;
}

 解析如下：

2. qsort 使用举例

 2.1 使用qsort函数排序整型数据

qsort 是库函数，这个函数可以完成任意类型数据的排序。

 https://cplusplus.com/

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

void qsort(
	void* base,  //base指向了要排序的数组的第一个元素
	size_t num,  //base指向的数组中的元素个数（待排序的数组的元素的个数）
	size_t size, //base指向的数组中元素的大小（单位是字节）
	int (*compar)(const void* p1, const void* p2)//函数指针——指针指向的函数是用来比较数组中的2个元素的
)

将一组整型数据排序为升序： 

#include 

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

int cmp_int(const void* p1, const void* p2)
{
	return *(int*)p1 - *(int*)p2;
}

//测试 qsort 排序整型数据
void test1()
{
	int arr[10] = { 3,2,4,5,1,6,7,9,8,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	print_arr(arr, sz);
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	print_arr(arr, sz);
}


int main()
{
	//将一组数据排序为升序
	test1();
	return 0;
}

如果排序的是结构体呢？

//测试qsort排序结构体数据
struct Stu
{
	char name[20];//名字
	int age;
};

结构体的排序是不能直接使用<、>、==进行比较。

（1）可以按年龄进行排序；

int cmp_stu_by_age(const void* p1, const void* p2)
{
	return ((struct Stu*)p2)->age - ((struct Stu*)p1)->age;
    //结构体才能这么写
}

void test2()
{
	struct Stu arr[] = { {"zhangsan", 20}, {"lisi", 38}, {"wangwu", 18} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
}

 （2）可以按名字进行排序；

名字是字符串，两个字符串不能使用> < ==，而是使用库函数strcmp - string compare

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

void test3()
{
	struct Stu arr[] = { {"zhangsan", 20}, {"lisi", 38}, {"wangwu", 18} };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}

3. qsort 函数的模拟实现

qsort是一个库函数，可以直接使用。它的实现是使用快速排序算法来排序。

 

用冒泡排序模拟qsort函数：（以整型为例）

void Swap(char* buf1, char*buf2, size_t width)
{
	int i = 0;
	for (i = 0; i < width; i++) 
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

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


int cmp_int(const void* p1, const void* p2)
{
	return *(int*)p1 - *(int*)p2;
}

void bubble_sort2(void* base, size_t sz, size_t width, int (*cmp)(const void*p1, const void*p2))
//                  起始位置    元素个数     元素大小
{
	int i = 0;
	//趟
	for (i = 0; i < sz - 1; i++)
	{
		//每一趟冒泡排序的过程
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			//if (arr[j] > arr[j + 1])
			if(cmp((char*)base + j * width, (char*)base + (j + 1) * width)>0)
			{
				/*int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;*/
				//交换
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}


void test3()
{
	//设计和实现bubble_sort2(),这个函数能够排序任意类型的数据
	int arr[] = { 3,1,5,7,9,2,4,0,8,6 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort2(arr, sz, sizeof(arr[0]), cmp_int);
	print_arr(arr, sz);
}

int main()
{
	test3();
	return 0;
}

结构体：

#include 
#include 
#include 

void Swap(char* buf1, char*buf2, size_t width)
{
	int i = 0;
	for (i = 0; i < width; i++) 
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

void bubble_sort2(void* base, size_t sz, size_t width, int (*cmp)(const void*p1, const void*p2))
//                  起始位置    元素个数     元素大小
{
	int i = 0;
	//趟
	for (i = 0; i < sz - 1; i++)
	{
		//每一趟冒泡排序的过程
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			//if (arr[j] > arr[j + 1])
			if(cmp((char*)base + j * width, (char*)base + (j + 1) * width)>0)
			{
				/*int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;*/
				//交换
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
	}
}

struct Stu
{
	char name[20];
	int age;
};

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

int cmp_stu_by_age(const void* p1, const void* p2)
{
	return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}

void test4()
{
	struct Stu arr[] = { {"zhangsan", 18},{"lisi", 35},{"wangwu", 15}};
	int sz = sizeof(arr) / sizeof(arr[0]);
	//bubble_sort2(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
	bubble_sort2(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
	//打印arr数组的内容
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%s %d\n", arr[i].name, arr[i].age);
	}
}


int main()
{
	test4();
	return 0;
}