【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.mzph.cn/news/170257.shtml

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

相关文章

java学习part11继承

java学习part11继承

1.类的继承 继承为了让类之间建立联系&#xff0c;同时复用代码。 子类和父类的同名函数构成重写&#xff0c;能覆盖&#xff0c;除非用super.xx()调。 同名属性不会覆盖&#xff0c;而是并存&#xff0c;用super.xx调。 2.子类初始化 子类会自动调用父类无参构造super() 3.重…
阅读更多...
如何把自己银行卡里的钱转账充值到自己支付宝上？

如何把自己银行卡里的钱转账充值到自己支付宝上？

原文来源&#xff1a;https://www.caochai.com/article-4524.html 支付宝余额是支付宝核心功能之一&#xff0c;主要用于网购支付、线下支付、转账等场景。用户可以将银行卡、余额宝等资金转入或转出至支付宝余额&#xff0c;实现快速转账和支付。 如何把自己银行卡里的钱转账…
阅读更多...
PyCharm 安装插件Vue

PyCharm 安装插件Vue

一、打开PyCharm工具 File -> Settings -> Plugins 二、在项目中添加Vue.js的依赖项。 npm install vue 三、页面应用
阅读更多...
基于51单片机的百叶窗控制系统设计

基于51单片机的百叶窗控制系统设计

**单片机设计介绍&#xff0c; 基于51单片机的百叶窗控制系统设计 文章目录 一 概要二、功能设计设计思路 三、 软件设计原理图 五、 程序六、 文章目录 一 概要 基于51单片机的百叶窗控制系统设计可以分为硬件设计和软件设计两个方面。下面是一个简要的设计介绍&#xff1a; …
阅读更多...
【微服务专题】SpringBoot自动配置简单源码解析

【微服务专题】SpringBoot自动配置简单源码解析

目录 前言阅读对象阅读导航前置知识什么是自动配置0.1 基本概念0.2 SpringBoot中的【约定大于配置】0.3 从SpringMVC看【约定大于配置】0.4 从Redis看【约定大于配置】0.5 小结 笔记正文一、EnableAutoConfiguration源码解析二、SpringBoot常用条件注解源码解析2.1 自定义条件注…
阅读更多...
HCIP-七、IS-IS 综合实验

HCIP-七、IS-IS 综合实验

七、IS-IS 综合实验 实验拓扑实验需求及解法1.如图所示&#xff0c;配置所有路由器的接口IP地址。2.运行IS-IS&#xff0c;进程号13.IS-IS优化4.路径优化 实验拓扑 实验需求及解法 本实验模拟IS-IS综合网络&#xff0c;完成以下需求&#xff1a; 1.如图所示&#xff0c;配置所…
阅读更多...
2017年7月13日 Go生态洞察：向Go 2迈进

2017年7月13日 Go生态洞察：向Go 2迈进

&#x1f337;&#x1f341; 博主猫头虎&#xff08;&#x1f405;&#x1f43e;&#xff09;带您 Go to New World✨&#x1f341; &#x1f984; 博客首页——&#x1f405;&#x1f43e;猫头虎的博客&#x1f390; &#x1f433; 《面试题大全专栏》 &#x1f995; 文章图文…
阅读更多...
影刀RPA_boss直聘翻页（避坑）

影刀RPA_boss直聘翻页（避坑）

boss直聘翻页这里有个坑 问题&#xff1a; 无限循环中&#xff0c;点击下一页按钮&#xff0c;直到不可点击为止。 发现&#xff0c;在点到第5页的时候&#xff0c;再次点击下一页&#xff0c;直接就点击了页码10&#xff0c;导致流程直接就结束了。 在第5页进行校验&#xff0…
阅读更多...
Unity 场景切换

Unity 场景切换

Unity场景切换可使用以下方法&#xff1a; 1、SceneManager.LoadScene()方法&#xff1a; using UnityEngine.SceneManagement;// 切换到Scene2场景 SceneManager.LoadScene("Scene2"); 2、使用SceneManager.LoadSceneAsync()方法异步加载场景&#xff0c;异步加载…
阅读更多...
2005-2023年6月中国全球投资追踪数据（China-Global-Investment-Tracker-2023-Spring）

2005-2023年6月中国全球投资追踪数据（China-Global-Investment-Tracker-2023-Spring）

2005-2023年6月中国全球投资追踪数据&#xff08;China-Global-Investment-Tracker-2023-Spring&#xff09; 1、时间;2005-2023年6月 2、来源&#xff1a;American Enterprise Institute 3、指标&#xff1a;Year、Month、Investor、Quantity、in、Millions、Share、Size、…
阅读更多...
大一统模型 Universal Instance Perception as Object Discovery and Retrieval 论文阅读笔记

大一统模型 Universal Instance Perception as Object Discovery and Retrieval 论文阅读笔记

Universal Instance Perception as Object Discovery and Retrieval 论文阅读笔记 一、Abstract二、引言三、相关工作实例感知通过类别名进行检索通过语言表达式的检索通过指代标注的检索 统一的视觉模型Unified Learning ParadigmsUnified Model Architectures 四、方法4.1 Pr…
阅读更多...
罗技M590鼠标usb优联连接不上

罗技M590鼠标usb优联连接不上

手里有一个罗技M590鼠标从18年4月一直用到现在&#xff0c;质量很好&#xff0c;除了滚轮有些松别的没毛病。最近一台笔记本电脑办公不太够用&#xff0c;又领了一个台式机&#xff0c;就想到M590支持双模连接&#xff0c;并且支持Flow&#xff0c;就把usb优联接收器从电池仓拿…
阅读更多...
Java学习路径：入门学习、深入学习、核心技术，操作案例和实际代码示例

Java学习路径：入门学习、深入学习、核心技术，操作案例和实际代码示例

学习路径&#xff1a;入门学习、深入学习、核心技术&#xff0c; 每个主题都包括很多的操作案例和实际代码示例。 a. 入门学习&#xff1a; 1. 基础语法&#xff1a; 变量和数据类型&#xff1a; // 定义和初始化变量 int age 25;// 不同数据类型的声明 double price 19.99…
阅读更多...
React基础入门

React基础入门

文章目录 创建项目组件和事件更新状态导出组件jsx react是目前最流行的前端框架&#xff0c;几乎也不用太介绍了。 创建项目 首先下载node.js&#xff0c;安装成功后&#xff0c;最好换成国内的源 npm config set registry https://registry.npm.taobao.org然后就可以使用脚…
阅读更多...
AI动画制作 StableDiffusion

AI动画制作 StableDiffusion

1.brew -v 2.安装爬虫项目包所必需的python和git等系列系统支持部件 brew install cmake protobuf rust python3.10 git wget pod --version brew link --overwrite cocoapods 3.从github网站克隆stable-diffusion-webui爬虫项目包至本地 ssh-add /Users/haijunyan/.ssh/id_rs…
阅读更多...
jQuery 第十一章（表单验证插件推荐）

jQuery 第十一章（表单验证插件推荐）

文章目录 前言jValidateZebra FormjQuery.validValValidityValidForm BuilderForm ValidatorProgressionformvalidationjQuery Validation PluginjQuery Validation EnginejQuery ValidateValidarium后言 前言 hello world欢迎来到前端的新世界 &#x1f61c;当前文章系列专栏&…
阅读更多...
mysql 更改密码

mysql 更改密码

由于两台设备的mysql数据库的密码不一样&#xff0c;开发时每次连接数据库都需要更改配置文件&#xff0c;所以想修改一下mysql数据库的密码。 mysql 修改密码千万不要直接修改&#xff0c;直接修改的话会出现两种情况&#xff1a; 1&#xff0c;修改成功&#xff0c;无法登录。…
阅读更多...
基于时隙的多重冗余流指纹模型

基于时隙的多重冗余流指纹模型

文章信息 论文题目&#xff1a;基于时隙的多重冗余流指纹模型 期刊&#xff08;会议&#xff09;&#xff1a;网络与信息安全学报 时间&#xff1a;2023 级别&#xff1a;CCF C 概述 为确保内生网络流量安全可信&#xff0c;本文在研究流水印及其扩展的流指纹机制的基础上&a…
阅读更多...
小程序中的大道理之二--抽象与封装

小程序中的大道理之二--抽象与封装

继续扒 接着 上一篇 的叙述, 健壮性也有了, 现在是时候处理点实际的东西了, 但我们依然不会一步到底, 让我们来看看. 一而再地抽象(Abstraction Again) 让我们继续无视那些空格以及星号等细节, 我们看到什么呢? 我们只看到一整行的内容, 当传入 3 时就有 3 行, 传入 4 时就…
阅读更多...
明道云伙伴成果与展望

明道云伙伴成果与展望

摘要&#xff1a;这篇文章介绍了明道云在过去一年的成果以及未来的计划。明道云将把更多资源和精力投入到伙伴身上&#xff0c;提供更全面的支持&#xff0c;包括产品特性、展业支持和 GTM &#xff08;Go-To-Market&#xff09;支持三个方面。在产品特性方面&#xff0c;明道云…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023