【C语言】回调函数、转移表、qsort 使用与基于qsort改造冒泡排序

---

数组指针/指针数组

	int arr1[5] = { 1,2,3,4,5 };int (*p1)[5] = &arr1;   //p1是数组指针变量int* arr2[5] = { 0 };   //arr2是指针数组

指针数组是存放指针的数组，本质是数组。
数组指针是指向数组的指针，本质是指针。
数组指针类型：(去掉变量名，剩下的就是类型)

int (*)[5]                  //数组指针类型

函数指针

函数名本身就是函数指针。

int Add(int x, int y)
{return x + y;
}int (*pf)(int, int) = &Add;   //pf就是存放函数地址(指针)的变量，函数指针变量

函数指针类型和数组指针类型相似，如下：

	int (*)(int, int)         //函数指针类型

通过函数指针调用函数：

int x = (*pf)(10, 20);
printf("%d\n", x);

因为函数名本身就是函数地址，所以前面的&Add 和 调用函数时的(*p) 中的取地址符和*不加也可以达到一样的效果。

函数指针数组

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 (*padd)(int, int) = &Add;
int (*psub)(int, int) = ⋐
int (*pmul)(int, int) = &Mul;
int (*pdiv)(int, int) = &Div;
// 类比 int arr[5]
int (*pfarr[4])(int, int) = { padd ,psub,pmul,pdiv };
//下面这样这可以
int (*pfarr[4])(int, int) = { Add, Sub, Mul, Div };

上面的pfarr就是函数指针数组的变量名，函数指针数组最好在函数指针变量的基础上改造得到，也就是在函数指针变量的变量名后面加[ ]。
函数指针数组的理解可以类比普通的数组，比如 int
arr[5]，一个存放5个整型变量的数组，把它的变量名和中括号(arr[5])去掉剩余的就是数组存放变量的类型，放在函数指针数组里也一样，把pfarr[4]去掉剩余的int(*)(int, int)就是数组里存放的变量类型。

函数指针数组用途(转移表)

我们先来看下面实现的一个简易计算器：

void menu()
{printf("********************\n");printf("*** 1.add  2.sub ***\n");printf("*** 3.mul  4.div ***\n");printf("***   0.exit     ***\n");printf("********************\n");
}int input = 0;
int a = 0;
int b = 0;
int r = 0;do{menu();printf("请选择：");scanf("%d", &input);switch (input){case 1:printf("请输入两个操作数：");scanf("%d %d", &a, &b);r = Add(a, b);printf("r = %d\n", r);break;case 2:printf("请输入两个操作数：");scanf("%d %d", &a, &b);r = Sub(a, b);printf("r = %d\n", r);break;case 3:printf("请输入两个操作数：");scanf("%d %d", &a, &b);r = Mul(a, b);printf("r = %d\n", r);break;case 4:printf("请输入两个操作数：");scanf("%d %d", &a, &b);r = Div(a, b);printf("r = %d\n", r);break;case 0:printf("退出计算器\n");break;default:printf("选择错误，重新选择\n");break;}} while (input);

我们可以看到虽然可以实现计算器的功能，但是代码非常冗长，并且如果要增加更多运算函数的话还会增加更多的case，想要简化代码就可以用函数指针数组，把函数存放在函数指针数组里，想要调用函数直接下标访问这个函数指针数组就行了，这里我们想要让数组下标和菜单选择数字对应的话就需要在数组开头增加一个空指针，让下标依次向后挪一位。

	int (*fparr[])(int, int) = {NULL,Add,Sub,Mul,Div};do{menu();printf("请选择：");scanf("%d", &input);if (input > 0 && input <= 4){printf("请输入两个操作数：");scanf("%d %d", &a, &b);//fparr[input]是数组下标访问函数对象printf("r = %d\n", fparr[input](a, b)); }else if (input == 0){printf("退出计算器\n");break;}else{printf("选择错误，重新选择\n");}}while(input);

这样的方法又名转移表。

回调函数

回调函数就是⼀个通过函数指针调⽤的函数。
如果你把函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被⽤来调⽤其所指向的函数时，被调⽤的函数就是回调函数。回调函数不是由该函数的实现⽅直接调⽤，⽽是在特定的事件或条件发⽣时由另外的⼀⽅调⽤的，⽤于对该事件或条件进⾏响应。
补充：至于回调函数为什么只能传函数指针类型而不能直接传递函数类型，因为这是C语言语法特性决定的，就算传递的是函数类型，编译器也会将它隐式转化为函数指针类型。
下面我们举个例子：

void calc(int (*pf)(int, int))
{int a = 0;int b = 0;int r = 0;printf("请输入两个操作数：");scanf("%d %d", &a, &b);r = pf(a, b);printf("r = %d\n", r);
}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);

之前我们实现的计算器switch-case部分非常冗余，有很多重复的代码，case1-4的四行代码只有调用运算函数那一行有区别，但是我们直接把代码封装成函数那又需要写四个函数，所以这里就可以用回调函数。
首先写一个回调函数calc，参数是运算函数对应的函数指针，所以每一个case只用去调用calc函数，根据不同的函数指针参数再在calc函数体中调用对应的运算函数。

qsort函数

qsort函数是C语言的一个库函数，它是基于快速排序算法实现的，这个函数可以用来排序任意类型数据。

我们来分析一下它的四个参数：

其中compar函数需要我们重点关注，这是我们自己设计的比较函数，C标准对这个函数是有约定的：

compar函数返回值有三类，当参数p1指向的元素大于参数p2指向的元素时，返回大于0的数字，当参数p1指向的元素等于于参数p2指向的元素时，返回0，参数p1指向的元素小于参数p2指向的元素时，返回小于0的数字。
因为qsort默认是排升序的，所以我们按照上面的规定实现比较函数传给qsort后最后结果为升序，如果要排降序就需要实现比较函数时把大小于号反号。
下面我们就来使用一下qsort，比较函数需要我们自己实现：

int cmp_int(const void* e1, const void* e2)
{//e1 e2 是void*，需要强制类型转换后才能使用(解引用)return *(int*)e1 - *(int*)e2;
}void test02()
{int arr[] = { 4, 1, 2, 3, 6, 8, 7 };size_t sz = sizeof(arr) / sizeof(arr[0]);qsort(arr, sz, sizeof(arr[0]), cmp_int);for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++){printf("%d ", arr[i]);}
}

比较结构体类型数据也是可以的：

typedef struct stu
{char name[20];size_t age;
}stu;cmp_struct_by_name(const void* e1, const void* e2)
{return strcmp(((stu*)e1)->name, ((stu*)e2)->name);
}cmp_struct_by_age(const void* e1, const void* e2)
{return ((stu*)e1)->age - ((stu*)e2)->age;
}void test03()
{stu arr[] = { {"jiyi", 7}, {"xiaoba", 8}, {"wusaqi", 6}, };size_t sz = sizeof(arr) / sizeof(arr[0]);qsort(arr, sz, sizeof(arr[0]), cmp_struct_by_age);
}

按名字比较时需要调用strcmp函数，我们查文档可以看到strcmp函数的返回值正好和我们要实现的比较函数逻辑一致，所以比较函数直接返回strcmp函数的返回值就行了。

基于qsort改造冒泡排序

我们以前实现的冒泡排序只能排整型数据，我们想让它适配更多类型的数据，就需要对它进行改造，这里模拟qsort的方式对我们自己的冒泡排序进行改造，我们先分析需要改造哪些地方：

一、首先是参数，我们要比较不同类型数据就需要按照qsort的参数实现方式进行传递。
第一个参数传递数组首元素的地址，有了地址才能知道待排序数据在哪里和第一个元素的地址，方便以第一个元素的地址为基准指针加数字访问到数组后面的元素(要配合第三个参数使用，因为第一个参数的类型的void*，无法直接加减数字操作，也无法确定强制类型转换的类型)。
第二个参数传递数组的元素个数，用于确定循环躺数。
第三个参数传递单个元素的单位大小，因为无法直接传递参数类型，所以传递单个元素的单位大小来间接确定元素类型。因为首元素地址是void*，无法直接以首元素地址为基准指针加数字访问到数组后面的元素，这里有一个思路就是将首元素地址强转成char*,用它加单位数乘以第三个参数大小就可以访问到单位位置的元素，比如(int*)base + j * (width) 就可以访问到指向int数组的第j个元素的指针，然后再把指针作为参数传给对应的比较函数，在比较函数内部再对指针解引用访问数据大小并比较。
第四个参数是我们自己实现的比较函数。

二、然后是比较函数部分传递我们自己实现的比较函数。

三、最后是swap，因为不知道数据的类型，所以不能直接交换，在前面参数部分已经将首元素指针类型强转成了char*，不如将计就计，在交换部分还是以char类型来交换，不管你的数据类型大小有多少字节，以char类型形式一个字节一个字节的交换，一共交换width次。

int cmp_int(const void* e1, const void* e2)
{//e1 e2 是void*，需要强制类型转换后才能使用 return *(int*)e1 - *(int*)e2;
}swap(char* p1, char* p2, int width)
{for (width; width > 0; width--){char tmp = *p1;*p1 = *p2;*p2 = tmp;p1++;p2++;}
}Bubble_sort(void* base, int sz, int width, int (*cmp)(const void* e1, const void* e2))
{int flag = 1;  //默认有序for (int i = 0; i < sz - 1; i++)  //躺数{for (int j = 0; j < sz - 1 - i; j++){//(char*)arr + j * widthif (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0){swap((char*)base + j * width, (char*)base + (j + 1) * width, width);flag = 0;}}if (flag == 1)break;}
}print(int* arr , int sz)
{for (int i = 0; i < sz; i++){printf("%d ", arr[i]);}printf("\n");
}void test04()
{int arr[] = { 4, 1, 2, 3, 6, 8, 7 };size_t sz = sizeof(arr) / sizeof(arr[0]);Bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);print(arr, sz);
}

源码

p1:

#include <stdio.h>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 test01()
{int arr1[5] = { 1,2,3,4,5 };int (*p1)[5] = &arr1;         //p1是数组指针变量//int (*)[5]                  //数组指针类型int* arr2[5] = { 0 };         //arr2是指针数组int (*pf)(int, int) = &Add;   //pf就是存放函数地址(指针)的变量，函数指针变量//int (*)(int, int)           //函数指针类型int x = (*pf)(10, 20);printf("%d\n", x);
}void test02()
{int (*padd)(int, int) = &Add;int (*psub)(int, int) = &Sub;int (*pmul)(int, int) = &Mul;int (*pdiv)(int, int) = &Div;// 类比 int arr[5]int (*pfarr[4])(int, int) = { Add, Sub, Mul, Div };
}void menu()
{printf("********************\n");printf("*** 1.add  2.sub ***\n");printf("*** 3.mul  4.div ***\n");printf("***   0.exit     ***\n");printf("********************\n");
}void test03()
{int input = 0;int a = 0;int b = 0;int r = 0;do{menu();printf("请选择：");scanf("%d", &input);switch(input){case 1:printf("请输入两个操作数：");scanf("%d %d", &a, &b);r = Add(a, b);printf("r = %d\n", r);break;case 2:printf("请输入两个操作数：");scanf("%d %d", &a, &b);r = Sub(a, b);printf("r = %d\n", r);break;case 3:printf("请输入两个操作数：");scanf("%d %d", &a, &b);r = Mul(a, b);printf("r = %d\n", r);break;case 4:printf("请输入两个操作数：");scanf("%d %d", &a, &b);r = Div(a, b);printf("r = %d\n", r);break;case 0:printf("退出计算器\n");break;default:printf("选择错误，重新选择\n");break;}} while (input);
}void test04()
{int input = 0;int a = 0;int b = 0;int r = 0;int (*fparr[])(int, int) = {NULL,Add,Sub,Mul,Div};do{menu();printf("请选择：");scanf("%d", &input);if (input > 0 && input <= 4){printf("请输入两个操作数：");scanf("%d %d", &a, &b);printf("r = %d\n", fparr[input](a, b));}else if (input == 0){printf("退出计算器\n");break;}else{printf("选择错误，重新选择\n");}}while(input);//do//{//	menu();//	printf("请选择：");//	scanf("%d", &input);//	switch (input)//	{//	case 1://		printf("请输入两个操作数：");//		scanf("%d %d", &a, &b);//		r = Add(a, b);//		printf("r = %d\n", r);//		break;//	case 2://		printf("请输入两个操作数：");//		scanf("%d %d", &a, &b);//		r = Sub(a, b);//		printf("r = %d\n", r);//		break;//	case 3://		printf("请输入两个操作数：");//		scanf("%d %d", &a, &b);//		r = Mul(a, b);//		printf("r = %d\n", r);//		break;//	case 4://		printf("请输入两个操作数：");//		scanf("%d %d", &a, &b);//		r = Div(a, b);//		printf("r = %d\n", r);//		break;//	case 0://		printf("退出计算器\n");//		break;//	default://		printf("选择错误，重新选择\n");//		break;//	}//} while (input);
}void calc(int (*pf)(int, int))
{int a = 0;int b = 0;int r = 0;printf("请输入两个操作数：");scanf("%d %d", &a, &b);r = pf(a, b);printf("r = %d\n", r);
}void test05()
{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);
}int main()
{//test01();//test02();//test03();//test04();test05();return 0;
}

p2:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>//Bubble_sort(int arr[], int sz)
//{
//    int flag = 1;  //默认有序
//    for (int i = 0; i < sz - 1; i++)  //躺数
//    {
//        for (int 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;
//                flag = 0;
//            }
//
//        }
//        if (flag == 1)
//            break;
//    }
//}
//test01()
//{
//    int arr[] = { 4, 1, 2, 3, 6, 8, 7 };
//    Bubble_sort(arr, 7);
//    for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
//    {
//        printf("%d ", arr[i]);
//    }
//}int cmp_int(const void* e1, const void* e2)
{//e1 e2 是void*，需要强制类型转换后才能使用 return *(int*)e1 - *(int*)e2;
}//print(int* arr)
//{
//    for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
//        {
//            printf("%d ", arr[i]);
//        }
//}//void test02()
//{
//    int arr[] = { 4, 1, 2, 3, 6, 8, 7 };
//    size_t sz = sizeof(arr) / sizeof(arr[0]);
//    qsort(arr, sz, sizeof(arr[0]), cmp_int);
//
//    for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
//    {
//        printf("%d ", arr[i]);
//    }
//}typedef struct stu
{char name[20];size_t age;
}stu;cmp_struct_by_name(const void* e1, const void* e2)
{return strcmp(((stu*)e1)->name, ((stu*)e2)->name);
}cmp_struct_by_age(const void* e1, const void* e2)
{return ((stu*)e1)->age - ((stu*)e2)->age;
}//void test03()
//{
//    stu arr[] = { {"jiyi", 7}, {"xiaoba", 8}, {"wusaqi", 6}, };
//    size_t sz = sizeof(arr) / sizeof(arr[0]);
//    qsort(arr, sz, sizeof(arr[0]), cmp_struct_by_age);
//}swap(char* p1, char* p2, int width)
{for (width; width > 0; width--){char tmp = *p1;*p1 = *p2;*p2 = tmp;p1++;p2++;}
}Bubble_sort(void* base, int sz, int width, int (*cmp)(const void* e1, const void* e2))
{int flag = 1;  //默认有序for (int i = 0; i < sz - 1; i++)  //躺数{for (int j = 0; j < sz - 1 - i; j++){//(char*)arr + j * widthif (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0){swap((char*)base + j * width, (char*)base + (j + 1) * width, width);flag = 0;}}if (flag == 1)break;}
}//void test_func(void* p1)
//{
//    p1[1];
//}print(int* arr , int sz)
{for (int i = 0; i < sz; i++){printf("%d ", arr[i]);}printf("\n");
}void test04()
{int arr[] = { 4, 1, 2, 3, 6, 8, 7 };size_t sz = sizeof(arr) / sizeof(arr[0]);Bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);print(arr, sz);
}int main()
{//test01();//test02();//test03();test04();return 0;
}

以上就是小编分享的全部内容了，如果觉得不错还请留下免费的关注和收藏 如果有建议欢迎通过评论区或私信留言，感谢您的大力支持。
一键三连好运连连哦~~