【C语言】回调函数

一、回调函数的定义

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

二、qsort函数的实现

qsort函数是一个快排函数；

qsort函数需要传的参数分别是：首元素地址，元素的个数，每个元素的大小（字节为单位），一个比较函数（需要自己实现）；

排列数组：

			int compare(const void* p1,const void* p2)
			{
				return *(int*)p1 - * (int*)p2;		//强制转换为int*再解引用；需要用什么类型比较就强转为什么类型
			}
			
			void Print(int* arr,int sz)
			{
				int i = 0;
				for (i = 0; i < sz; i++)
				{
					printf("%d ", arr[i]);
				}
			}
			
			int main()
			{
				int arr[] = { 10,9,8,5,6,7,4,3,1,2 };
				int sz = sizeof(arr) / sizeof(arr[0]);
				qsort(arr, sz, sizeof(arr[0]), compare);
				Print(arr,sz);
				return 0;
			}

排列结构体中的成员：

			typedef struct Student				//将struct Student类型起别名为S
			{
				char name[20];
				int age;
			}S;
			
			int compare(void* p1, void* p2)
			{
				return strcmp(((S*)p1)->name, ((S*)p2)->name);		//strcmp()库函数比较两个字符串大小
			}
			
			
			void Print(S* s,int sz)
			{
				int i = 0;
				for (i = 0; i < sz; i++)
				{
					printf("%s\n",s[i].name);
				}
			}
			
			int main()
			{
				S s[] = { {"zhangsan",20 },{"lisi",30} };
				int sz = sizeof(s) / sizeof(s[0]);		//结构体的大小一样可以用sizeof计算
				qsort(s, sz, sizeof(s[0]), compare);
				Print(s,sz);
				return 0;
			}

在以上两种类型排序中，compare函数都是回调函数；

三、利用冒泡排序的思想模拟实现qsort()函数

这个bubble_sort函数可以排序任意类型的数据

两个核心函数：

交换函数，这里传参传的分别是两个元素的地址和每个元素的类型大小（字节为单位）；将每个元素的地址一个字节一个字节交换，当每个字节都交换了，两个元素也就交换了；

			void Swap(char* p1, char* p2, int width)
			{
				int i = 0;
				//将每个元素的地址一个字节一个字节交换，当每个字节都交换了，两个元素也就交换了
				for (i = 0; i < width; i++)
				{
					char tmp = *p1;
					*p1 = *p2;
					*p2 = tmp;
					p1++;
					p2++;
				}
			}

（1）这里使用void*指针接收，因为不知道使用者会传什么类型的指针过来，而void * 是无具体类型的指针，所以它可以接收任何类型的地址；但void * 的指针不能解引用操作符，因为根本不知道它是什么类型的指针；

（2）(char*)base + j * width：base是首元素地址，+j是访问它下一个元素，但不知道使用者创建的compare函数传入的首地址是什么类型，所以用void接收，所以这里我们将它强制转换为char类型，因为char指针+1跳过一个字节，使base跳过j*width个字节，相当于跳过j个元素

（3）bubble_sort（）函数的实现部分；相当于qsort函数的实现，但qsort的核心思想使用快排，以下这个函数的核心思想是冒泡排序；

			void bubble_sort(void* base, size_t num, size_t width, int (*compare)(const void* p1,const void* p2))
			{
				size_t i = 0;
				//确定趟数
				for (i = 0; i < num - 1; i++)
				{
					//一趟冒泡排序的过程
					size_t j = 0;
					for (j = 0; j < num - 1 - i; j++)
					{
						//模拟比较base[j] base[j+1]
						//base是首元素地址，+j是访问它下一个元素，但不知道使用者创建的compare函数传入的首地址是什么类型，所以用void接收，所以这里我们将它强制转换为char*类型，因为char*指针+1跳过一个字节，使base跳过j*width个字节，相当于跳过j个元素
						if (compare((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
						{
							//若compare函数返回>0，就交换
							Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
						}
					}
				}
			}

以下是使用者使用代码部分，假如排列一个整型数组：

			int compare(const void* p1, const void* p2)
			{
				return *(int*)p1 - *(int*)p2;
			}
			
			
			void Print(int* arr, int sz)
			{
				int i = 0;
				for (i = 0; i < sz; i++)
				{
					printf("%d ", arr[i]);
				}
			}
			
			
			void test1()
			{
				int arr[] = { 10,3,1,2,4,6,5,9,8,7 };
				int sz = sizeof(arr) / sizeof(arr[0]);
				bubble_sort(arr, sz, sizeof(arr[0]), compare);
				Print(arr, sz);
			}
			
			int main()
			{
				test1();
				return 0;
			}

这里的compare函数依然是回调函数；