网站单页模板制作软件百度自动驾驶技术

六、函数指针数组

字符指针数组 - 存放字符指针的数组 char* arr[10]

整型指针数组 - 存放整型指针的数组 int* arr[10]

函数指针数组 - 存放函数指针的数组

void my_strlen()
{}
int main()
{//指针数组char* ch[5];int arr[10] = {0};//pa是是数组指针int (*pa)[10] = &arr;//pf是函数指针int (*pf)(const void*) = &my_strlen;//函数指针数组int (*pf[10])(const void*) = {&my_strlen};//pf的类型是int (*[10])(const void*)return 0;
}

解释：pf 先和 [ ] 结合，说明 pf是数组，数组的内容是 int (*)() 类型的函数指针。

6.1转移表

函数指针数组的用途：转移表

举例：写一个计算器实现整数的加、减、乘、除

计算器的一般实现：

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 Mui(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();printf("请选择:>");scanf("%d",&input);switch(input){case 1:printf("请输入两个操作数:>");scanf("%d %d",&x,&y);ret = Add(x,y);printf("%d\n",ret);break;case 2:printf("请输入两个操作数:>");scanf("%d %d",&x,&y);ret = Sub(x,y);printf("%d\n",ret);break;case 3:printf("请输入两个操作数:>");scanf("%d %d",&x,&y);ret = Mul(x,y);printf("%d\n",ret);break;case 4:printf("请输入两个操作数:>");scanf("%d %d",&x,&y);ret = Div(x,y);printf("%d\n",ret);break;case 0:printf("退出计算器\n");break;default:printf("选择错误\n");break;}}while(input);return 0;
}

使用函数指针数组实现：

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 Mui(int x,int y)
{return x * y;
}int Div(int x,int y)
{return x / y;
}//用函数指针数组存放上述函数的地址
//转移表
int (*pf[5])(int,int) = {NULL,Add,Sub,Mul,Div};//第一个元素是NULL(0)，是为了使得函数与菜单中的选项数字一致int main()
{int input = 0;int x = 0;int y =0;int ret = 0;do{menu();printf("请选择:>");scanf("%d",&input);if(input == 0){printf("退出计算器\n");break;}else if(input >= 1 && innput <=4){printf("请输入两个操作数:>");scanf("%d %d",&x,&y);ret = pf[input](x,y);printf("%d\n",ret);}else{printf("选择错误\n");}}while(input);    return 0;
}

七、指向函数指针数组的指针

指向函数指针数组的指针是一个指针，指针指向一个数组，数组的元素都是函数指针

int main()
{//数组指针int arr[10];int (*pa)[10] = &arr;//函数指针int (*pf)(int,int) = &test;//函数指针数组int (*pf[5])(int ,int) = {test};pf[0] = test;//ppf是指向函数指针数组的指针int (*(*ppf)[5])(int,int) = &pf//ppf的类型是int (*(*)[5])(int,int)return 0;
}

八、回调函数

回调函数就是⼀个通过函数指针调用的函数。

如果你把函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被用来调用其所指向的函数

时，被调用的函数就是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

可以使用回调函数来实现计算器，使其更加简化：

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 Mui(int x,int y)
{return x * y;
}int Div(int x,int y)
{return x / y;
}//以上都称为回调函数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;
}

把调用的函数的地址以参数的形式传递过去，使⽤函数指针接收，函数指针指向什么函数就调⽤什么函数，这⾥其实使⽤的就是回调函数的功能

8.1qsort函数的使用

首先回顾一下冒泡排序：思想：两两相邻的元素进行比较

例如进行升序排序：

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;}}}
}
int main()
{//对数组进行排序，升序int arr[10] = {9,8,7,6,5,4,3,2,1,0};int sz = sizeof(arr) / sizeof(arr[0]);bubble_sort(arr,sz);//0 1 2 3 4 5 6 7 8 9//打印int i = 0;for(i = 0;i <sz; i++){printf("%d ",arr[i]);}return 0;
}

冒泡排序是有缺点的：只能排序整数，结构体、浮点型等不可以

qsort函数的使用

库函数中有一个排序函数：qsort（快速排序）

void* base - 待排序的数组的起始位置（地址） 
size_t num - 数组元素个数
size_t size - 数组中每一个元素的大小（一个元素是几个字节）
int (*compar)(const void*, const void*) - 两个元素的比较函数（函数指针），第一个参数是进行比较的两个元素中第一个的地址，第二个参数是另一个元素地址
比较函数的参数是void*类型的原因：因为无法确定想要比较的类型是int、结构体等类型中的哪一种，所以设置成void（无具体类型）类型

int main()
{int a = 10;float f = 5.5f;int* p = &a;//p = &f;//如果把f的地址取出来赋给p，浮点型的地址赋给整型的指针，编译器会报警告：类型不兼容//如果写成void*的指针类型void* pp = &f;//void*的指针可以接收float类型的地址，且不会报警告pp = &a;//用void*的指针接收整型地址也不会警告//pp - 垃圾桶（可以接受任何类型的地址，因为pp是void*类型的指针变量，无具体类型）printf("%f\n", *pp);//不能直接打印，会报错，void*的指针不能直接解引用pp++;//进行++也不行，因为不知道具体类型，不知道具体加一步要走多远（大小不知道）return 0;
}

但是也有缺点：没有办法直接使用，因为void*的指针不能直接解引用，不知道具体类型，如果想要使用，要进行强制类型转换，就可以使用了

---------------------------------------------------------------------------------------------------------------------------------

进一步解析比较函数：当比较函数接收的两个元素进行比较时，p1>p2 - 返回大于0的数字

p1<p2 - 返回小于0的数字；p1=p2 - 等于0

前面我们说过要对数组进行升序排序，那么我们就可以根据以上的信息，转化为两个元素相减的结果，再根据此结果来判断是否需要进行交换 ，如果相减的结果大于0，说明p1>p2，要进行交换

qsort函数的使用需要包含头文件 #include <stdlib.h>

8.1.1使用qsort函数排序整型数据

#include <stdio.h>
#include <stdlib.h>int cmp_int(const void* p1,const void* p2)
{return *(int*)p1 - *(int*)p2;//升序return *(int*)p2 - *(int*)p1;//降序
}
int main()
{//对数组进行排序，升序int arr[10] = {9,8,7,6,5,4,3,2,1,0};int sz = sizeof(arr) / sizeof(arr[0]);qsort(arr,sz,sizeof(arr[0]),cmp_int);int i = 0;for(i = 0;i <sz; i++){printf("%d ",arr[i]);}return 0;
}

8.1.2使用qsort函数排序结构体数据

按照年龄排序：

#include <stdio.h>
#include <stdlib.h>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;
}int main()
{struct Stu s[3] = {{"zhangsan",20},{"lisi",50},{"wangwu",33}};int sz = sizeof(s) / sizeof(s[0]);qsort(s,sz,sizeof(s[0]),cmp_stu_by_age);int i = 0;for(i = 0;i < sz; i++){printf("姓名：%s 年龄：%d\n",s[i].name,s[i].age);}return 0;
}

按照姓名排序：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>struct Stu
{char name[20];int age;
};//按照学生的姓名来排序
int cmp_stu_by_name(const void* p1,const void* p2)
{return strcmp(((struct Stu*)p1)->name,((struct Stu*)p2)->name);
}int main()
{struct Stu s[3] = {{"zhangsan",20},{"lisi",50},{"wangwu",33}};int sz = sizeof(s) / sizeof(s[0]);qsort(s,sz,sizeof(s[0]),cmp_stu_by_name);int i = 0;for(i = 0;i < sz; i++){printf("姓名：%s 年龄：%d\n",s[i].name,s[i].age);}return 0;
}

字符串是按照字典序排序的：
字典序是一种基于字母或字符顺序的排列方式，类似于字典中单词的排列规则。在C语言中，常用于字符串或字符数组的比较和排序。

字典序的核心规则‌
‌逐字符比较‌：从左到右逐个比较字符的ASCII值。若字符不同，ASCII值较小的字符所在的字符串更小。若字符相同，继续比较下一个字符。
‌长度优先‌：若所有字符相同，则较短的字符串更小。
‌示例‌："apple" < "banana"（因为 'a' < 'b'）
"app" < "apple"（前三个字符相同，但前者更短）
‌C语言中的字典序实现‌：
使用标准库函数 strcmp
strcmp 是C语言标准库（<string.h>）中用于比较字符串的函数，按字典序返回结果：

‌返回值‌：
< 0：第一个字符串小于第二个。
= 0：两个字符串相等。
> 0：第一个字符串大于第二个。

注意事项：字符编码默认基于ASCII值，大写字母（A-Z，ASCII 65~90）比小写字母（a-z，ASCII 97~122）小

字符串以终止符\0结尾，比较时会自动处理

8.2qsort函数的模拟实现

根据qsort函数，改造冒泡排序，使得这个函数可以排序任意指定的数组（以冒泡排序的思维实现qsort函数）

8.2.1排序整型数组

//使用我们自己写的bubble_sort函数排序整型数组void Swap(char* a,char* b,int size)
{int i = 0;for(i = 0;i < size; i++){char tmp = *a;*a = *b;*b = tmp;a++;b++;}
}
int cmp_int(const void* p1,const void* p2)
{return *(int*)p1 - *(int*)p2;
}
void bubble_sort(void* base,size_t num,size_t size,int (*cmp)(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++){if(cmp((char*)base+j*size,(char*)base+(j+1)*size) > 0){Swap((char*)base+j*size,(char*)base+(j+1)*size,size);//实现两个元素的比较}}}
}
int main()
{int arr[10] = {9,8,7,6,5,4,3,2,1,0};int sz = sizeof(arr) / sizeof(arr[0]);bubble_sort(arr,sz,sizeof(arr[0]),cmp_int);int i = 0;for(i = 0;i < sz; i++){printf("%d ",arr[i]);}return 0;
}

8.2.2排序结构体数组

按照年龄排序：

struct Stu
{char name[20];int age;
};
void Swap(char* a,char* b,int size)
{int i = 0;for (i = 0; i < size; i++){char tmp = *a;*a = *b;*b = tmp;a++;b++;}
}
//按照年龄排序
int cmp_stu_by_age(const void* p1,const void* p2)
{return ((struct Stu*)p1)->age - ((struct Stu*)p2)->age;
}
void bubble_sort(void* base,size_t num,size_t size,int (*cmp)(const void* p1,const void* p2))
{//趟数int i = 0;for(i = 0;i < num -1; i++){int j = 0;for(j = 0;j < num-1-i; j++){if(cmp((char*)base+j*size,(char*)base+(j+1)*size) > 0){Swap(cmp((char*)base+j*size,(char*)base+(j+1)*size,size);}}}
}
int main()
{struct Stu s[3] = {{"zhangsan",20},{"lisi",50},{"wangwu",33}};int sz = sizeof(s) / sizeof(s[0]);bubble_sort(s,sz,sizeof(s[0]),cmp_stu_by_age);int i = 0;for(i = 0;i < sz; i++){printf("姓名：%s 年龄：%d\n",s[i].name,s[i].age);}return 0;
}

按照姓名排序：

struct Stu
{char name[20];int age;
};
void Swap(char* a,char* b,int size)
{int i = 0;for (i = 0; i < size; i++){char tmp = *a;*a = *b;*b = tmp;a++;b++;}
}
//按照姓名排序
int cmp_stu_by_name(const void* p1,const void* p2)
{return strcmp(((struct Stu*)p1)->name,((struct Stu*)p2)->name);
}
void bubble_sort(void* base,size_t num,size_t size,int (*cmp)(const void* p1,const void* p2))
{//趟数int i = 0;for(i = 0;i < num -1; i++){int j = 0;for(j = 0;j < num-1-i; j++){if(cmp((char*)base+j*size,(char*)base+(j+1)*size) > 0){Swap(cmp((char*)base+j*size,(char*)base+(j+1)*size,size);}}}
}
int main()
{struct Stu s[3] = {{"zhangsan",20},{"lisi",50},{"wangwu",33}};int sz = sizeof(s) / sizeof(s[0]);bubble_sort(s,sz,sizeof(s[0]),cmp_stu_by_name);int i = 0;for(i = 0;i < sz; i++){printf("姓名：%s 年龄：%d\n",s[i].name,s[i].age);}return 0;
}