回调函数及qsort应用实例&&使用回调函数模拟实现冒泡排序

本篇介绍：

• 指向函数指针数组的指针
• 回调函数
• qsort应用实例
• 使用回调函数，模拟实现qsort（采用冒泡的方式）

一、指向函数指针数组的指针

指向函数指针数组的指针是一个指针变量

指针指向一个数组，数组的元素都是函数指针

//指向函数指针数组的指针

void test(const char* str)
{
	printf("%s\n", str);
}
int main()
{
	void(*pt)(const char*) = &test;//函数指针

	//函数指针的数组
	void (*ptarr[2])(const char*);

	//指向函数指针数组的指针
	void(* (*pptarr)[2])(const char*) = &ptarr;
	return 0;
}

二、回调函数

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

我们可以将上一篇中的模拟实现一个计算器代码使用回调函数来实现：

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

	//调用对应的函数，pf 就是回调函数
    ret = pf(x, y);
	printf("%d\n", ret);
}

int main()
{
	int x = 0, y = 0;
	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;
}

三、qsort应用实例

首先我们先了解一下qsort函数是什么

我们再来看看它的参数：

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

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

第一个参数：指向待排序数组的第一个元素；

第二个参数：待排序的元素个数；

第三个参数：每个元素的大小单位是字节

第四个参数：指向一个函数，这个函数可以比较2个元素的大小。

compare函数是由使用者自己定义的，因为实现qsort函数的人并不知道我们想要对哪一种数据类型进行排序，所以它把compare函数的参数定义成了void* 的类型。

void* —— 无具体类型的指针，所以它可以接收任何类型的地址；void*的指针不能解引用操作符，只能给它进行强制类型转换。

例如：

int main()
{
    int a = 10;
    char* p = &a;        //int*
    void* p = &a;        //void* - 无具体类型的指针，所以它可以接收任何类型的地址
    *p;                        //错误，void*的指针不能解引用操作符
    p++;                     //错误
    *(int*)p;                //强制类型转换之后再解引用
    printf("%d ", *(int*)p);          //10
    return 0;
}

qsort函数对整型数据排序的使用：

#include <stdlib.h>
#include <assert.h>

//打印函数
void print(int arr[], int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}

//比较函数
int cmp_int(const void* p1, const void* p2)
{
	assert(p1 && p2);

	//将p1和p2强制转换成int*，因为我们是给int类型的数据排序。
	return (*(int*)p1) - (*(int*)p2);
}

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

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

qsort函数对结构体类型排序的使用：

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

typedef struct stu
{
	char name[20];//姓名
	int age;//年龄
}stu;

//打印结构体数组的内容
void print_stu(stu* s, int sz)
{
	for (int i = 0; i < sz; i++)
	{
		printf("%s\t%d\n", s[i].name, s[i].age);
	}
}

//通过学生的年龄来排序
int cmp_stu_age(const void* p1, const void* p2)
{
	assert(p1 && p2);
	return ((stu*)p1)->age - ((stu*)p2)->age;
}

//通过学生的名字来排序
int cmp_stu_name(const void* p1, const void* p2)
{
	assert(p1 && p2);
	return strcmp(((stu*)p1)->name, ((stu*)p2)->name);
}

void test2()
{
	stu s[3] = { {"zhangsan", 18}, {"lisi", 30}, {"wangwu", 25} };
	int sz = sizeof(s) / sizeof(s[0]);

    //通过年龄排序
	qsort(s, sz, sizeof(s[0]), cmp_stu_age);

    //通过姓名排序
	qsort(s, sz, sizeof(s[0]), cmp_stu_name);

    //打印
	print_stu(s, sz);
}

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

四、使用回调函数，模拟实现qsort（采用冒泡的方式）

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

//对整型数据比较
int cmp_int(const void* p1, const void* p2)
{
	assert(p1 && p2);
	//将p1和p2强制转换成int*，因为我们是给int类型的数据排序。
	return (*(int*)p1) - (*(int*)p2);
}

//通过学生的年龄来排序
int cmp_stu_age(const void* p1, const void* p2)
{
	assert(p1 && p2);
	return ((stu*)p1)->age - ((stu*)p2)->age;
}

//通过学生的名字来排序
int cmp_stu_name(const void* p1, const void* p2)
{
	assert(p1 && p2);
	return strcmp(((stu*)p1)->name, ((stu*)p2)->name);
}

//交换两个相邻元素
void Swap(char* buf1, char* buf2, int width)
{
	for (int i = 0; i < width; i++)
	{
		//我们的计算机一般是小端存储
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}


//模拟实现bubble_sort,使得可以对任意类型的数据排序
void bubble_sort(void* base, size_t num, size_t width, int(*pf)(const void* p1, const void* p2))
{
	for (size_t i = 0; i < num - 1; i++)
	{
		int flag = 1;
		for (size_t j = 0; j < num - 1 - i; j++)
		{
			//判断是否需要交换
			if (pf((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				flag = 0;
				//交换的实现
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
			}
		}
		if (flag)
			break;
	}
}

void test3()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);

	print(arr, sz);
}

void test4()
{
	stu s[3] = { {"zhangsan", 18}, {"lisi", 30}, {"wangwu", 25} };
	int sz = sizeof(s) / sizeof(s[0]);

    //按学生的年龄排序
	bubble_sort(s, sz, sizeof(s[0]), cmp_stu_age);

    //按学生的姓名排序
	bubble_sort(s, sz, sizeof(s[0]), cmp_stu_name);

	print_stu(s, sz);
}

int main()
{
	test3();//对整数类型数据进行排序
	test4();//对结构体类型数据进行排序
	return 0;
}

在bubble_sort 中我们着重需要考虑的是——是否需要交换，和如何进行交换：

将比较函数的参数强制转换成char*，因为一次只会移动一个字节，再加上j*width，就是往后走了一个元素类型的大小，即指向了下一个元素，对这两个元素进行比较，看看是否需要交换，如果需要交换，调用Swap函数。

Swap函数如何实现，因为我们的实参是char*类型，所以形参用char*来接收，并且将width的值（一个元素的大小）也传过去；将两个元素交换，可以把他们按一个字节一个字节分隔开，第一个元素的每个字节与第二个元素的每个字节逐个交换。

​​​​​​​