【C指针（五）】6种转移表实现整合longjmp()/setjmp()函数和qsort函数详解分析模拟实现

  🌈write in front :

🔍个人主页 ： @啊森要自信的主页

✏️真正相信奇迹的家伙，本身和奇迹一样了不起啊！

欢迎大家关注🔍点赞👍收藏⭐️留言📝>希望看完我的文章对你有小小的帮助，如有错误，可以指出，让我们一起探讨学习交流，一起加油鸭。 请添加图片描述

文章目录

  • 前言
  • 一、转移表
  • 二、回调函数是什么？
  • 三、qsort函数细解
    • 3.1 类比冒泡排序？
    • 3.2 qosrt函数超详解
    • 3.2.1qsort函数排序整型数据
    • 3.2.2 使⽤qsort排序结构数据
  • 四、 qsort函数的模拟实现
    • 4.1 模拟qsort整形数据
    • 4.2 模拟`qsort`排序结构数据
  • 总结

前言

本小节，我们将继续学习C语言转移表，什么是回调函数，回调函数又是什么？qsort函数怎么使用，怎么理解处理，要注意的细节，当然qsort使用举例，最后我们进行qsort函数的模拟实现！文章干货满满，走起！

一、转移表

C语言转移表是指根据一定条件，实现程序执行流程的跳转或转移的机制。

具体来说，C语言中实现转移表的主要方式有：

  1. goto语句：
    goto语句可以实现无条件跳转，直接跳转到指定标签所在的代码块
goto 标签名;

例如：

goto label;
  1. switch语句：
    switch语句根据表达式的值，选择性地执行一个代码块。它实现了有条件跳转。
switch(表达式)
{case 常数表达式1://语句break;case 常数表达式2:  //语句break;//其他casedefault://语句
}
  1. continue语句：
    continue 用于跳过循环体剩余部分，直接跳转到循环条件判断语句。

例如：

for(i=0;i<10;i++)
{if(i==5)continue;printf("%d",i);
}
  1. break语句：
    break 用于跳出整个循环或switch语句。

例如：

for(i=0;i<10;i++)
{if(i==5)break;printf("%d",i);
}
  1. return语句：
    return 用于从函数中返回。

例如：

int func()
{return 0;
}
  1. 拓展：longjmp()/setjmp():

setjmp()和longjmp()是C语言中的两个非常重要的函数，它们可以实现非局部跳转的功能。

  • setjmp()函数声明如下：
  int setjmp(jmp_buf env);

  • jmp_buf是可以保存环境信息的结构体。

  • setjmp()会将当前函数的执行环境信息保存到env中，并返回0。

  • 然后程序可以正常执行。

  • 当需要跳转时，调用longjmp(env, val);

    longjmp()函数声明如下：

 void longjmp(jmp_buf env, int val);

  • longjmp()第一个参数就是setjmp()保存的env。

  • 它会将程序跳转回setjmp()后面要执行的代码。

  • 但此时setjmp()会返回longjmp()第二个参数val,而不是0。
    jmp_buf env是setjmp和longjmp函数用来保存环境信息的结构体变量。

jmp_buf是一个预定义的数据类型，它用来描述一个环境的状态。

  • env是一个jmp_buf类型的变量。
  • 当调用setjmp(env)时，setjmp函数会将当前函数调用栈(包括函数参数、局部变量等环境信息)保存到env这个结构体变量中。
  • 之后程序可以正常执行。
  • 当需要非局部跳转时，调用longjmp(env, val)。longjmp函数第一个参数就是这个env。
  • longjmp通过env这个结构体，可以恢复到setjmp函数保存环境时的状态。实现一个“跳回”的效果。

小总结：

  • jmp_buf是一个结构体类型，它可以保存一个函数环境的状态信息。
  • env是一个此类型的变量，用于在setjmp和longjmp之间传递环境信息。
  • setjmp函数把当前环境信息保存到env中。
  • longjmp函数通过env这个结构体，实现恢复到setjmp时的环境状态，从而实现非局部跳转。

哎！当然你可以把env可以看作是一个“传送令牌”，只要通过longjmp把令牌改了，他就重新传送到setjmp，然后继续执行，它连接setjmp和longjmp,使得longjmp能找到正确的环境信息进行跳转。

所以通过setjmp()/longjmp()就实现了一个非局部跳转：程序似乎"跳回"到setjmp()后面要执行的代码，但实际上环境已经发生了变化。这在异常处理等场景中很有用。
工作原理是：

  1. setjmp()函数会保存当前函数调用栈(包括函数参数和局部变量等信息)的环境，并返回0。

  2. 之后程序可以正常执行。

  3. 当需要非局部跳转时，调用longjmp(),并将在setjmp()保存的环境作为参数传入。

  4. 这个时候程序就会跳转回setjmp()保存的环境，仿佛从setjmp()后面继续执行。但此时setjmp()会返回非0值。

举个例子

# define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <setjmp.h>jmp_buf env; //jmp_buf是一个预定义的数据类型，它用来描述一个环境的状态。//env是一个jmp_buf类型的变量。void func()
{//设置跳转点int ret = setjmp(env);if (0 == ret){//正常流程printf("In func()\n");//触发跳转longjmp(env, 1);}else{//跳转后流程printf("Jumped back to func()\n");}
}int main()
{func();return 0;
}

在这里插入图片描述

程序执行流程：

  1. 主函数调用func()函数。
  2. func()内首先调用setjmp()设置跳转点env。由于setjmp()第一次调用会返回0,所以进入if块。
  3. 打印"In func()"信息。
  4. 调用longjmp(),触发非局部跳转。
  5. 程序跳转回setjmp()设置的环境env,此时setjmp()返回1。
  6. 执行else块内的代码，打印"Jumped back to func()"。
  7. func()返回，主函数结束。

通过在函数内使用setjmp()/longjmp(),实现了从函数内非局部跳回函数外的功能。这与goto不同，可以实现跨函数的非顺序跳转。它常用于异常和错误处理等场景。

  1. C语言函数指针数组可以用来实现转移表。

具体来说：

  • 定义一个函数指针数组，元素类型为函数指针。

  • 每个数组元素都指向一个具体的函数。

  • 根据条件调用数组对应元素所指向的函数。

这与传统的switch语句实现转移的效果是一致的。

一个简单的示例：

// 函数定义
void func1() 
{printf("func1\n");
}void func2() 
{printf("func2\n"); 
}// 主函数
int main() 
{// 函数指针数组void (*funcs[])(void) = {func1, func2};int id = 1; // 条件值// 根据条件调用数组元素函数funcs[id]();return 0;
}

在这里插入图片描述

这样就实现了根据条件值动态调用不同函数的功能，相当于一个简单的转移表。

函数指针数组用于转移表的优点是：

  • 更灵活，可以在运行时动态添加/删除函数
  • 扩展性好，支持条件复杂情况下的多路径转移
  • 与传统switch语句相比代码更简洁清晰

所以总的来说，函数指针数组正是C语言实现转移表的一个很好的选择。它可以很好地替代switch语句实现更复杂的多路转移逻辑。
通过这个你可能不太能看出哪里能很好的替代switch语句，让我们来看一个典型的例子，实现一个计算器！！！

switch实现计算器：

主要实现计算器程序思路：

  1. 定义了四个运算函数add、sub、mul、div实现四则运算。

  2. main函数中：

  • 使用do while循环控制程序循环执行。

  • 打印菜单让用户选择运算类型。

  • 根据用户选择用switch case调用对应的运算函数。

  • 每次运算前输入两个操作数，运算后打印结果。

  1. 选择0退出循环，退出程序。
#include <stdio.h>int add(int a, int b)//加法
{return a + b;
}int sub(int a, int b)//减法
{return a - b;
}int mul(int a, int b)//乘法
{return a * b;
}int div(int a, int b)//除法
{return a / b;
}int main()
{int x, y;int input = 1;int ret = 0;do{printf("*************************\n");printf("****  1:add   2:sub   ***\n");printf("****  3:mul   4:div   ***\n");printf("****  0:exit   ....   ***\n");printf("*************************\n");printf("请选择：");scanf("%d", &input);switch (input)//选择{case 1:printf("输入两个操作数：");scanf("%d %d", &x, &y);ret = add(x, y);printf("ret = %d\n", ret);break;case 2:printf("输入两个操作数：");scanf("%d %d", &x, &y);ret = sub(x, y);printf("ret = %d\n", ret);break;case 3:printf("输入两个操作数：");scanf("%d %d", &x, &y);ret = mul(x, y);printf("ret = %d\n", ret);break;case 4:printf("输入两个操作数：");scanf("%d %d", &x, &y);ret = div(x, y);printf("ret = %d\n", ret);break;case 0:printf("退出程序\n");break;default:printf("选择错误，请重新选择\n");break;}} while (input);return 0;
}

在这里插入图片描述

实现是实现了,但是case里面的每个代码块除了ret = (?)(x,y);有点不同，其他都很相似，这么多代码重复写，会造成代码的冗余，如果我们又继续给用户增加功能，比如&，^,>>等等，然后一个功能我们就加一个case,case多了，代码重复的也多咋改变呢？

不着急，我们不是学习了函数指针数组吗？

我们可以把函数的地址存储在数组里面，然后通过指针访问数组下标（0,1,2,3,4,5...）,然后解引用找到我们要找到我们要实现函数的地址
然后给他传参，再接收他的计算的返回值不就搞定了。
哈哈哈哈！!掌声应该送给自己，说做就做！让我们继续往下走。
在这里插入图片描述

函数指针数组实现计算器：

思路：

  1. 定义了4个函数Add、Sub、Mul、Div,用于四则运算。

  2. menu()函数打印菜单界面。

  3. 定义了一个函数指针数组pfArr,元素类型为int (*)(int, int),可以存储这4个二元运算函数的地址。

  4. 在主函数中使用do-while循环不断运行：

    • 调用menu()打印菜单

    • scanf输入选择

    • 根据选择从pfArr数组中获取对应函数的地址

    • 调用该函数进行运算

    • 打印结果

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;
}int main()
{int input = 0;int x = 0;int y = 0;int ret = 0;do{menu();//函数指针数组的方式解决一下//这里的函数指针数组，我们称为转移表// 为什么这里要加NULL，直接{add,sub,mul,div}不行吗？如果真是可以的话，那我们观察他的下标  0   1   2   3此时此刻，如果我们选择1.add,那么（*p[1]）取出的地址是sub,这不对呀，如果我们在前面加一个NULL，{ NULL,add,sub,mul,div }下标为  0    1   2   3   4地址：*p[ 0 ] == 0,     *p[ 1 ] ==addint (*pfArr[])(int, int) = { NULL, Add, Sub, Mul, Div };//                           0     1    2    3    4printf("请选择:");scanf("%d", &input);if (input == 0){printf("退出计算器\n");}else if (input >= 1 && input <= 4){										printf("请输入两个操作数:");scanf("%d %d", &x, &y);ret = pfArr[input](x, y);           //（*p[input]）==add/sub/mul/div函数名，也就是函数的地址//（p[input]）也可以，*号有无，都相当于函数名，也是函数地址// 也就是ret=(p[input])(x,y);printf("%d\n", ret);}else{printf("选择错误，重新选择\n");}} while (input);return 0;
}

解释：
当input输入1, pfArr[1]取得Add的地址，然后通过Add函数的地址，执行指令。（当然同理input输入2,3,4也是同样的步骤）。
如果要增加功能，那么可以int (*pfArr[])(int, int) = { NULL, Add, Sub, Mul, Div };增加相应的功能，然后增加相应功能的代码块！
比如，你想要增加位运算(&, |, ^)的功能：

  1. 增加位运算函数：
int And(int x, int y) {return x & y;
}int Or(int x, int y) {return x | y;  
}int Xor(int x, int y) {return x ^ y;
}
  1. 修改菜单显示：
void menu() {printf("******************************\n");printf("****  1. add     2. sub   ****\n"); printf("****  3. mul     4. div   ****\n");printf("****  5. &       6. |     ****\n");printf("****  7. ^              ****\n");  printf("****  0. exit             ****\n");printf("******************************\n");}
  1. 增加函数指针：
int (*pfArr[])(int, int) = {NULL, Add, Sub, Mul, Div, And, Or, Xor};
  1. 判断函数选择范围：
if(input >= 1 && input <= 7) {ret = pfArr[input](x, y);}

这样就增加了位运算的功能选择了。

如果还需要其他运算，可以继续增加对应的函数和菜单显示即可。

但是，思考———>
int (*p[5])(int x, int y) = { NULL,add,sub,mul,div };那函数的add,sub,mul,div这些地址是不是也和一维数组一样，存储在函数指针数组里面，他们的地址是否是连续的呢？
解释：

函数地址在函数指针数组中的存储方式与一维数组类似，但有一点不同：

  • 函数指针数组pfArr中，add、sub等函数地址的存储是连续的，就像一维数组元素一样,如下标0,1,2,3,4这样连续存储后就可以访问了。

  • 但是，函数本身的代码可能不一定存储在连续内存地址中。

更准确地说：

  • 在函数指针数组pfArr中，add、sub等函数地址是以连续方式存储的。

  • 而函数本身的代码可能分散在不同代码段(code section)中，地址不一定连续。

举个例子：

假设add函数代码在地址0x00001000,sub函数代码在0x00002000,mul在0x00003000。

那么在函数指针数组pfArr中：

pfArr[1] 指向 add函数地址 0x00001000  
pfArr[2] 指向 sub函数地址 0x00002000
pfArr[3] 指向 mul函数地址 0x00003000

我们可以看到，pfArr[1]、pfArr[2]、pfArr[3]中的函数地址是以连续的方式存储在数组中的。

但是函数本身的代码地址0x00001000、0x00002000、0x00003000并不连续。

所以总结来说：

  • 函数指针数组pfArr中函数地址是连续存储的
  • 但函数代码本身不一定连续存储在内存中

在这里插入图片描述

二、回调函数是什么？

C语言中的回调函数是指在函数调用的过程中，被另外一个函数作为参数传递并调用的函数。

回调函数的主要特征如下：

  1. 回调函数必须事先定义。

  2. 回调函数的地址作为参数传递给另一个函数，这个函数称为主函数。

  3. 主函数在适当的时候，通过调用回调函数的地址来调用回调函数。

一个典型的回调函数使用场景例子：

// 回调函数定义
void callback_func(int value) 
{printf("value is %d\n", value);
}// 主函数定义
void main_func(void (*callback)(int)) 
{int num = 10;// 调用回调函数callback(num); 
}int main() 
{// 注册回调函数main_func(callback_func);return 0;
}

注：回调函数的特点是函数的调用关系由使用者在运行时决定，而不是在编译时就确定，这提供了更大的灵活性。

那可不可以使用回调函数实现计算器呢？

  1. 定义一个通用的计算函数calc,它接收一个函数指针作为参数。
  2. 在main函数中，根据用户选择直接调用calc函数，并传入相应的运算函数。
  3. 回调函数是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");
}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;
}//calc功能强大了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(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函数细解

3.1 类比冒泡排序？

通过前面我们学过冒泡排序，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[10] = { 3,1,5,2,4,6,8,7,0,9 };int sz = sizeof(arr) / sizeof(arr[0]);print_arr(arr, sz);bubble_sort(arr, sz);print_arr(arr, sz);return 0;
}

在这里插入图片描述

在这里插入图片描述

3.2 qosrt函数超详解

库函数的学习和查看⼯具很多，⽐如：
C/C++官⽅的链接：https://zh.cppreference.com/w/c/header
cplusplus.com：https://legacy.cplusplus.com/reference/clibrary/
qsort函数是C标准库中用于对数组进行快速排序的函数。(注：qsort函数底层使用的排序算法就是快速排序。)

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

.- [ ] 分析定义:

  • base指向要排序的数组首地址。

  • num表示数组元素个数。

  • size表示每个元素的大小，以字节为单位。

  • compar是比较函数，它接收两个void指针，返回值小于0表示第一个参数小于第二个参数，等于0表示相等，大于0表示第一个参数大于第二个参数。

.- [ ] 特点：

  • qsort使用快速排序算法，时间复杂度为O(nlogn)。

  • 调用qsort时，需要提供一个比较函数compar来判断两个元素的大小关系。

  • 比较函数通过void指针间接访问元素，避免与数据类型绑定，实现了最大程度的通用性。

  • qsort会在内部调用比较函数多次对数组进行排序，这就是回调机制的实现。

  • qsort是inplace排序，不需要额外的空间。

在这里插入图片描述

在这里插入图片描述

3.2.1qsort函数排序整型数据

#include <stdio.h>
#include <stdlib.h>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排序整型数据的
int main()
{int arr[10] = { 4,2,5,3,1,6,7,8,0,9 };int sz = sizeof(arr) / sizeof(arr[0]);print_arr(arr, sz);//打印前qsort(arr, sz, sizeof(arr[0]), cmp_int);//arr->数组首元素地址//sz->数组元素个数也可以这样写sz==sizeof(arr)/sizeof(arr[0])//sizeof(arr[0])->数组元素大小，这里字节大小为4//cmp_int比较函数print_arr(arr, sz);//打印后
}

在这里插入图片描述

3.2.2 使⽤qsort排序结构数据

  1. 定义结构体类型
struct Stu
{char name[20];//名字int age;
};
  1. 定义比较函数
  • 怎么比较2个结构体数据？ - 不能直接使用 > < ==比较
  • 可以按照名字比较
  • 可以按照年龄比较
//按照年龄比较
int cmp_stu_by_age(const void* p1, const void* p2)
{return ((struct Stu*)p2)->age - ((struct Stu*)p1)->age;
}
  1. 声明结构体数组和元素个数
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);
}

代码实现：

# define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>测试qsort函数排序结构体数据
struct Stu
{char name[20];//名字int age;
};int cmp_stu_by_age(const void* p1, const void* p2)
{return ((struct Stu*)p2)->age - ((struct Stu*)p1)->age;
}
void print(struct Stu arr[], int sz)
{for (int i = 0; i < sz; i++){printf("%s %d\n", arr[i].name, arr[i].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);print(arr, sz);
}//	//两个字符串不能使用> < ==
//	//而是使用库函数strcmp - string compareint 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);print(arr, sz);}int main()
{test3();//姓名排序//test2();//年龄排序return 0;
}

运行test2()//年龄排序
在这里插入图片描述

四、 qsort函数的模拟实现

4.1 模拟qsort整形数据

  1. 主函数：

    • 定义int测试数据
    • 调用bubble排序
    • 打印结果验证
#include <stdio.h>
int main()
{int arr[] = { 3, 1, 5, 8, 4, 2, 9, 6, 7, 0 };int i = 0;  //元素个数                   //元素大小bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);//数组首元素地址arr                                    //比较函数for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++){printf("%d ", arr[i]);}printf("\n");return 0;
}

  1. bubble函数：

    • 接收基地址、元素个数、元素大小、比较函数作为参数
    • 实现冒泡排序核心算法
    • 通过传递的比较函数int_cmp来决定排序顺序
    • 使用_swap函数交换元素
void bubble(void* base, int count, int size, int(*cmp)(void*, void*))
{int i = 0;int j = 0;for (i = 0; i < count - 1; i++){for (j = 0; j < count - i - 1; j++){if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0){_swap((char*)base + j * size, (char*)base + (j + 1) * size, size);}}}
}

  1. int_cmp函数：

    • 定义一个int类型的数据比较函数
    • 通过减法实现两个int*指针所指向的数据比较
    • 返回值大于0表示p1大于p2（升序）,小于0表示p1小于p2（降序）
    • 实现了冒泡排序中的比较规则
int int_cmp(const void* p1, const void* p2)
{return (*(int*)p1 - *(int*)p2);
}

  1. _swap函数：

    • 定义泛型数据交换函数
    • 通过循环交换每个字节实现数据交换
    • 使用char*来交换，实现数据类型无关
void _swap(void* p1, void* p2, int size)
{int i = 0;for (i = 0; i < size; i++){char tmp = *((char*)p1 + i);*((char*)p1 + i) = *((char*)p2 + i);*((char*)p2 + i) = tmp;}
}

在这里插入图片描述

总结：
每个代码块实现的功能：

  • 主函数： 测试驱动开发
  • bubble: 实现冒泡排序算法
  • int_cmp: 提供比较规则
  • _swap: 实现泛型数据交换

在这里插入图片描述

4.2 模拟qsort排序结构数据

各个代码块分析如下：

  1. struct Stu定义结构体类型，包含姓名和年龄字段。
# define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>struct Stu
{char name[20];int age;
};
  1. Swap函数实现泛型数据交换，通过循环交换每个字节实现数据交换。
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++;}
}
  1. bubble_sort2函数实现冒泡排序算法，和普通冒泡排序区别在于使用void*作为参数，通过width实现对结构体进行排序。
void bubble_sort2(void* base, int sz, int 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);}}}
}
  1. cmp_stu_by_age函数实现结构体比较规则，根据年龄字段进行比较。
int cmp_stu_by_age(const void* p1, const void* p2)
{return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}
  1. test4函数定义测试数据，调用bubble_sort2进行排序，打印结果验证。
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_age);//打印arr数组的内容int i = 0;for (i = 0; i < sz; i++){printf("%s %d\n", arr[i].name, arr[i].age);}
}
  1. main函数调用test4函数进行测试。
int main()
{//模拟结构体按年龄排序test3();return 0;
}

在这里插入图片描述

小总结：

  • struct Stu定义了需要排序的数据类型
  • Swap函数实现数据交换
  • bubble_sort2实现泛型冒泡排序
  • cmp_stu_by_age定义了结构体比较规则
  • test4函数测试驱动开发

总结

一、转移表
利用函数指针数组实现转移表是动态规划算法解决最优子结构问题时使用的一种技术。它记录了子问题的解，避免重复计算。

二、回调函数是什么?
回调函数是指在函数调用后，被当作参数传递给另一个函数的函数。调用方在需要时，会调用被调用方内部的这个函数。

三、qsort函数细解

3.1 类比冒泡排序?
qsort函数实现的也是冒泡排序算法。不同之处在于：

  • qsort是通用排序函数，可以对任意数据类型进行排序，而冒泡排序只能对数组进行排序;

  • qsort通过回调函数来指定元素的比较方式，而冒泡排序直接比较元素值;

  • qsort内部实现采用快速排序思想，而不是纯粹的冒泡排序。

3.2 qsort函数超详解

qsort函数原型：

void qsort(void *base, size_t num, size_t size, int (*compar)(const void*, const void*));
  • base:待排序数组首地址
  • num:数组元素个数
  • size:每个元素大小
  • compar:比较函数回调，返回值小于0时交换元素

3.2.1 qsort排序整型数据

直接传入整型比较函数如int cmp(const void*, const void*)

3.2.2 使用qsort排序结构数据

定义结构体比较函数，通过强制类型转换比较结构体字段

四、qsort函数的模拟实现

4.1 模拟qsort整形排序
实现了一个简单快速排序函数，可以对整型数组排序。

4.2 模拟qsort结构体排序 同样实现快速排序，但使用结构体比较函数作为回调。

感谢你的收看，如果文章有错误，可以指出，我不胜感激，让我们一起学习交流，如果文章可以给你一个帮助，可以给博主点一个小小的赞😘
请添加图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/218069.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

嵌入式虚拟机原理

嵌入式虚拟机原理

欢迎关注博主 Mindtechnist 或加入【智能科技社区】一起学习和分享Linux、C、C、Python、Matlab&#xff0c;机器人运动控制、多机器人协作&#xff0c;智能优化算法&#xff0c;滤波估计、多传感器信息融合&#xff0c;机器学习&#xff0c;人工智能等相关领域的知识和技术。关…
阅读更多...
计算机应用基础_错题集_PPT演示文稿_操作题_计算机多媒体技术操作题_文字处理操作题---网络教育统考工作笔记007

计算机应用基础_错题集_PPT演示文稿_操作题_计算机多媒体技术操作题_文字处理操作题---网络教育统考工作笔记007

PPT演示文稿操作题 提示：PPT部分操作题 将第2～第4张幻灯片背景效果设为渐变预置的“雨后初晴”效果（2）设置幻灯片放映方式
阅读更多...
STM32 CAN协议讲解以及代码

STM32 CAN协议讲解以及代码

STM32 CAN 文章目录 STM32 CAN前言一、CAN外设1.主控制寄存器CAN_MCR2.位时序寄存器CAN_BTR3.CAN的发送邮箱4.CAN的接收FIFO5.验收筛选器 二、代码配置1.初始化2.发送数据3.接收数据4.main.c 前言 前面学习了CAN的一些理论知识&#xff0c;他在我们的STM32里面是怎么用的呢 前…
阅读更多...
英特尔和 ARM 将合作开发移动芯片技术，如何看待双方合作？

英特尔和 ARM 将合作开发移动芯片技术，如何看待双方合作？

英特尔和 ARM 将合作开发移动芯片技术&#xff0c;如何看待双方合作&#xff1f; 最近市场传出Arm要自产芯片&#xff0c;供智能手机与笔电等使用后&#xff0c;外媒指Arm自产芯片将由英特尔晶圆代工部门打造&#xff0c;变成英特尔晶圆代工客户。将采用英特尔18A工艺&#xff…
阅读更多...
支付功能、支付平台、支持渠道如何测试？

支付功能、支付平台、支持渠道如何测试？

有学员提问&#xff1a;作为一个支付平台&#xff0c;接入了快钱、易宝或直连银行等多家的渠道&#xff0c;内在的产品流程是自己的。业内有什么比较好的测试办法&#xff0c;来测试各渠道及其支持的银行通道呢&#xff1f; 作为产品&#xff0c;我自己办了十几张银行卡方便测…
阅读更多...
P13 C++ 类 | 结构体内部的静态static

P13 C++ 类 | 结构体内部的静态static

目录 01 前言 02 类内部创建静态变量的例子 03 在类的内部创建静态变量的作用 04 最后的话 01 前言 本期我们讨论 static 在一个类或一个结构体中的具体情况。 在几乎所有面向对象的语言中&#xff0c;静态在一个类中意味着特定的东西。这意味着在类的所有实例中&#xff…
阅读更多...
【Linux】fork()

【Linux】fork()

文章目录 一、fork()是什么&#xff1f;二、fork()干了什么&#xff1f;三、fork()怎么用&#xff1f; 一、fork()是什么&#xff1f; fork()函数其实是在Linux系统中用于创建一个新的进程。让我们看看Linux中是怎么描述的&#xff1f;运行man fork。 RETURN VALUE On success…
阅读更多...
libmosquitto库的一个bug,任务消息id(mid)分配后不起作用

libmosquitto库的一个bug,任务消息id(mid)分配后不起作用

代码如图所示: 当订阅了所有主题后,每个主题的mid是他们的下标索引加100的数字,可是实际打印出来的值是: mid依然是1,2,这个参数在这里失效了,不知道是bug还是mqtt的什么机制?
阅读更多...
Linux内核中的overlay文件系统

Linux内核中的overlay文件系统

一、简介 Docker 内核实现容器的功能用了linux 内核中的三个特性 Namespace、Cgroup、UnionFs&#xff0c;今天我们来说一下UnionFs。 linux UnionFs 实现的是overlay 文件系统 OverlayFs 文件系统分为三层&#xff0c; lower 是只读层 Upper 是可读写 Merged 是 lower 和U…
阅读更多...
Spring Boot - 瘦身大作战：优雅应对Spring Boot Fat Jar

Spring Boot - 瘦身大作战：优雅应对Spring Boot Fat Jar

文章目录 Fat Jar瘦身pom修改copy lib启动 -Dloader.path验证 源码分析前置阅读spring-boot-loader 依赖类继承关系PropertiesLauncher属性配置 附 pom.xml Fat Jar 【pom.xml】 <?xml version"1.0" encoding"UTF-8"?> <project xmlns"ht…
阅读更多...
管理类联考——写作——考点+记忆篇——论证有效性分析——记忆

管理类联考——写作——考点+记忆篇——论证有效性分析——记忆

文章目录 论证有效性分析得分要点、寻找漏洞方法论证有效性分析五大逻辑漏洞类型论证有效性分析的具体写法论证有效性分析十大解题思路&#xff08;上&#xff09;方法一&#xff1a;理想法方法二&#xff1a;极端法方法三&#xff1a;其他因素法方法四&#xff1a;可行性法 论…
阅读更多...
nginx反向代理解决跨域实践

nginx反向代理解决跨域实践

需求实现 本地请求百度的一个搜索接口&#xff0c;用nginx代理解决跨域思路&#xff1a;前端和后端都用nginx代理到同一个地址8080&#xff0c;这样访问接口就不存在跨域限制 本地页面 查询一个百度搜索接口&#xff0c;运行在http://localhost:8035 index.js const path …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023