【c语言——指针详解（4）】

---

---

作者主页

一、回调函数是什么？

回调函数就是⼀个通过函数指针调⽤的函数。
如果你把函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被⽤来调⽤其所指向的函数
时，被调⽤的函数就是回调函数。在上一篇文章中，我们实现计算器的第三种代码其实就是运用了回调函数。

//回调函数
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");
}void Calc(int (*pf)(int, int))
{int x = 0;int y = 0;int ret = 0;printf("请输入2个数\n");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(Add);//Add是地址，传递给函数指针Calc，Calc再去调用函数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的使⽤

#include<stdlib.h>//qsort函数的头文件
#include<string.h>//strcmp的头文件

qsort是用来排序的库函数，直接用来排序数据
底层使用的是快速排序的方式，qsort函数可以排序任意类型的数据。
排序方式有很多种，例如：
选择排序
插入排序
冒泡排序
快速排序
希尔排序
…

1、使⽤qsort函数排序整型数据

使用qsort函数前，我们先写一个冒泡排序的函数，对一组整型数据进行排序，排序为升序。

void bubble_sort(int arr[], int sz)
{//趟数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]){int tmp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = tmp;}}}
}void print_arr(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]);bubble_sort(arr, sz);print_arr(arr, sz);return 0;
}

像这个函数只能排序整型数据，如果要排序其他类型数据的时候就无能为力了，这时就要用到qsort函数了。
接下来我们看一下qsort函数的原型：

void qsort(void* base, //指针，指向的是待排序的数组的第一个元素size_t num, //是base指向的待排序数组的元素个数size_t size,//base指向的待排序数组的元素的大小int(*compar)(const void*)//函数指针-指向的就是两个元素的比较函数)void*类型的指针是无具体类型的指针，它的作用就是接收任何类型的地址。
这种类型的指针不能直接解引用，也不能+-整数的运算qsort 函数的使用者-明确的知道要排序的是什么数据，这些数据应该如何比较，所以提供两个元素的比较函数

用qsort函数来实现一下冒泡排序：

#include<stdlib.h>//qsort函数的头文件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)//比较函数
{/* if (*(int*)p1 > *(int*)p2)//将void*类型的指针p1强制转换为int*类型再解引用，p1和p2就是两个要比较的元素，如9和8{return 1;}else if (*(int*)p1 == *(int*)p2)return 0;elsereturn -1; *///简化：return *(int*)p1 - *(int*)p2;//想要降序就交换这两个数据
}void test1()
{int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };int sz = sizeof(arr) / sizeof(arr[0]);qsort(arr, sz, sizeof(arr[0]), cmp_int);//4个参数print_arr(arr, sz);
}int main()
{test1();return 0;
}

2、使⽤qsort排序结构数据

写一段代码私用qsort排序结构体的数据：

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

这里的两个结构体元素怎么比较大小？

1. 按照名字比较-字符串比较–strcmp，strcmp是按照对应着字符串中的字符的ASCII码值比较的
2. 按照年龄比较-整型比较

#include<stdlib.h>//qsort函数的头文件
#include<string.h>//strcmp的头文件struct Stu 
{char name[20];int age;
};int cmp_stu_by_age(const void* p1, const void* p2) //按年龄排序
{return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age; // 升序  // return ((struct Stu*)p2)->age - ((struct Stu*)p1)->age; // 降序  
}int cmp_stu_by_name(const void* p1, const void* p2) //按名字排序
{return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);//强制类型转换为结构体指针
}void print_stu_arr(struct Stu arr[], int sz) //打印结构体数据
{for (int i = 0; i < sz; i++) {printf("Name: %s, Age: %d\n", arr[i].name, arr[i].age);}
}void test2() 
{struct Stu arr[3] = { {"zhangsan", 20}, {"lisi", 35}, {"wangwu", 18} };int sz = sizeof(arr) / sizeof(arr[0]);//qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);//按年龄排序qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);//按名字排序print_stu_arr(arr, sz);
}int main() 
{test2();return 0;
}

三、qsort函数的模拟实现

可以使⽤回调函数，来模拟实现qsort（采⽤冒泡的⽅式），bubble—sort来模拟实现qsort,。在这之前我们先看一组代码。

void bubble_sort(int arr[], int sz)
{//趟数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]){int tmp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = tmp;}}}
}

上述代码可以用来排序整数数据。
在使用冒泡排序的情况下，假设我要改造这个函数，让他能够排序任意类型的数据，哪些地方需要改造呢？我们知道两个整型元素可以直接使用>比较，但是两个字符串，两个结构体元素是不能使用>比较的。
可以把两个元素比较的方法，封装成函数，然后把函数的地址传给排序函数。

#include<stdlib.h>//qsort函数的头文件
#include<string.h>//strcmp的头文件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); // 升序  // return (*(int*)p2 - *(int*)p1); // 降序  
}void Swap(char* buf1, char* buf2, size_t width) //这是对地址的四个字节（width）一 一交换从而实现整个交换
{int i = 0;for ( i = 0; i < width; i++) {char tmp = *buf1;*buf1 = *buf2;*buf2 = tmp;buf1++;buf2++;}
}void bubble_sort(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++){//比较arr[j]和arr[j+1]if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)//改变{//交换两个元素Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);}}}
}void test3() 
{int arr[] = { 3, 1, 7, 8, 5, 3, 4, 9, 0, 6 };int sz = sizeof(arr) / sizeof(arr[0]);bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);print_arr(arr, sz);
}int main() 
{test3();return 0;
}

这段代码实现了一个冒泡排序算法，用于对一个整型数组进行排序，并打印排序后的结果。

• print_arr(int arr[], int sz)：这个函数接受一个整型数组arr和数组的大小sz作为参数，并打印数组中的每个元素。
• cmp_int(const void* p1, const void* p2)：这是一个比较函数，用于比较两个整型值。它接受两个指向void的指针（任何类型），将它们转换为指向int的指针，并返回两个整数的差值。这个函数的返回值用于确定排序的顺序（升序或降序）。
• Swap(char* buf1, char* buf2, size_t width)：这个函数用于交换两个元素的内容。它接受两个指向char的指针（代表元素的起始地址）和一个size_t类型的值width（代表元素的宽度，以字节为单位）。然后，它逐个字节地交换两个元素的内容。注意，对于整型数组来说，这种方法不是最高效的，因为它逐个字节地处理数据，而不是直接交换整个整型值。
• bubble_sort(void* base, size_t sz, size_t width, int (cmp)(const void p1, const void* p2))：这是冒泡排序算法的实现。它接受一个指向数组起始位置的指针base、数组的大小sz、元素的宽度width和一个比较函数cmp作为参数。算法通过多次遍历数组，比较并交换相邻的元素，直到数组完全排序。

同样这个模拟实现的冒泡排序算法也能对结构体元素进行比较：

#include<stdlib.h>//qsort函数的头文件
#include<string.h>//strcmp的头文件struct Stu
{char name[20];int age;
};int cmp_stu_by_age(const void* p1, const void* p2) //按年龄排序
{return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age; // 升序  // return ((struct Stu*)p2)->age - ((struct Stu*)p1)->age; // 降序  
}int cmp_stu_by_name(const void* p1, const void* p2) //按名字排序
{return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);//强制类型转换为结构体指针
}void print_stu_arr(struct Stu arr[], int sz) //打印结构体数据
{for (int i = 0; i < sz; i++){printf("Name: %s, Age: %d\n", arr[i].name, arr[i].age);}
}void Swap(char* buf1, char* buf2, size_t width) //这是对地址的四个字节（width）一 一交换从而实现整个交换
{int i = 0;for ( i = 0; i < width; i++) {char tmp = *buf1;*buf1 = *buf2;*buf2 = tmp;buf1++;buf2++;}
}void bubble_sort(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++){//比较arr[j]和arr[j+1]if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)//改变{//交换两个元素Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);}}}
}void test4()
{struct Stu arr[3] = { {"zhangsan",20},{"lisi",35},{"wangwu",18} };int sz = sizeof(arr) / sizeof(arr[0]);bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);//bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);print_stu_arr(arr, sz);
}int main() 
{test4();return 0;
}

按名字排序：