目录
函数指针数组
数组是一个存放相同类型数据的存储空间，前面博主已经讲解了指针数组， 比如
int *arr[10];
//数组的每个元素是int*把函数的地址存到一个数组中，那这个数组就叫函数指针数组，下面时函数指针的数组的定义
int (*parr1[10])();
parr1 parr1 先和 [] 结合，说明 parr1是数组，数组的·内容是 int (*)() 类型的函数指针。
函数指针数组的用途：
转移表
接下来我将通过代码的形式来介绍一下函数指针的数组，这里博主编译一个简单的计算机进行讲解，代码如下
//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");
//}
//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("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;
//}对于这段代码，我们发现这段代码有很多相同且类似的代码
printf("请输入两个操作数:");
scanf("%d %d", &x, &y);
ret = Add(x, y);
printf("ret = %d\n", ret);这就造成了冗余，那么有没有什么办法进行解决呢？其实我们这里就可以用函数指针组来进行解决
首先我们发现，我们所用的加减乘除函数，除了名字不同，参数与返回值都相同，是统一类型
数组的定义就是里面存放的为同一类型的数据
那么我们就可以进行使用，函数指针数组建立如下
int (* pfArr[5])(int, int) = {NULL, Add, Sub, Mul, Div};
//数组的一个元素为NULL，是为了此程序在输入时方便
数组为pfArr；数组类型就为int(*)(int,int)
使用如下
int main()
//{
// int input = 0;
// int x = 0;
// int y = 0;
// int ret = 0;
// //函数指针数组的使用 - 转移表
// int (* pfArr[5])(int, int) = {NULL, Add, Sub, Mul, Div};
// // 0 1 2 3 4
// do
// {
// menu();
// printf("请选择:>");
// scanf("%d", &input);
// if (input >= 1 && input <= 4)
// {
// printf("请输入两个操作数:");
// scanf("%d %d", &x, &y);
// ret = pfArr[input](x, y);
// printf("ret = %d\n", ret);
// }
// else if(input == 0)
// {
// printf("退出计算器\n");
// }
// else
// {
// printf("选择错误，重新选择\n");
// }
// } while (input);
//
// return 0;指向函数指针数组的指针
大家想既然有函数指针数组，那么有没有指向函数指针数组的指针呢？
答案肯定是有的，指向函数指针数组的指针是一个 指针， 指针指向一个 数组 ，数组的元素都是 函数指针 ;
那我们该如何定义呢？定义如下
void test(const char* str)
{
printf("%s\n", str);
}
int main()
{
//函数指针pfun
void (*pfun)(const char*) = test;
//函数指针的数组pfunArr
void (*pfunArr[5])(const char* str);
pfunArr[0] = test;
//指向函数指针数组pfunArr的指针ppfunArr
void (*(*ppfunArr)[5])(const char*) = &pfunArr;
return 0;
}回调函数
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
接下博主运用上面的简易计算器来实现一个回调函数
根据回调函数的定义，我们知道我们需要一个函数的指针为参数，传参后还要调用该指针所指向的函数
那我们首先先把函数作为指针并进行传参，这里博主创建以下函数代码
void Calc(int (*pf)(int, int))此代码中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("ret = %d\n", ret);
//}那么就可以进行实现了，实现代码如下
//int main()
//{
// int input = 0;
// int x = 0;
// int y = 0;
// int ret = 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（快速排序）
博主在前面讲过冒泡排序，它可以将一个int型的数组里的数进行排序，但是就只能进行整数的排序，这里我们就引入了qsort函数，qsort函数为排序神器，搭配头文件#include<stlib.h>
我们来看一下这个函数的使用格式吧
void qsort(void* base,size_t num,size_t size,int (*cmp)(const void*, const void*));里面这么多东西，那都是什么意思呢？解释如下
//void qsort(void* base, //指向了需要排序的数组的第一个元素
// size_t num, //排序的元素个数
// size_t size,//一个元素的大小，单位是字节
// int (*cmp)(const void*, const void*)//函数指针类型 - 这个函数指针指向的函数，能够比较base指向数组中的两个元素
// );整型数组的排序
废话不多说，我们直接开始测试整型数组的排序
//test1()
//{
// int arr[10] = { 3,1,5,2,4,7,9,6,8,0 };
// int sz = sizeof(arr) / sizeof(arr[0]);
// //默认是升序的
// qsort(arr, sz, sizeof(arr[0]), cmp_int);
// print(arr, sz);//打印函数
//}我们通过定义一个函数cmp_int，通过cmp_int返回的参数来确定排序规则，需要注意的是：cmp_int函数的参数需要以const void *p1,const void *p2的形式来定义，表示a和b的类型是未确定的，在return中进行强制类型转换为int型。*(int*)p1-*(int*)p1表示以递增顺序，若想以递减只需将p1和p2换位,实现如下
//int cmp_int(const void* p1, const void* p2)
//{
// return (*(int*)p1 - *(int*)p2);//数据类型强制转换
//}结构题排序
我们刚刚说了，qsort是一个万能排序，不仅可以对整型进行排序。这里博主再给大家来一个结构题排序，创建以下结构体
//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;
//}
//
//void test2()
//{
// struct Stu arr[] = { {"zhangsan", 20}, {"lisi", 50},{"wangwu", 15} };
// int sz = sizeof(arr) / sizeof(arr[0]);
// qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_age);
//}按名字排序
使用如下
//int cmp_stu_by_name(const void* p1, const void* p2)
//{
// return strcmp(((struct Stu*)p1)->name, ((struct Stu*)p2)->name);
//名字不能直接比较，得用strcmp进行比较
//}
//
//void test3()
//{
// struct Stu arr[] = { {"zhangsan", 20}, {"lisi", 50},{"wangwu", 15} };
// int sz = sizeof(arr) / sizeof(arr[0]);
// qsort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
//}模拟实现qsort函数（冒泡排序）
qsort函数使用的是快排序，而博主模拟的qsort使用的是冒泡排序
这里博主创建一个bubble_sort函数进行模拟，创建如下
void bubble_sort(void* base, int num, int size, int (*cmp)(const void*, const void*))因为是一个冒泡排序所以使用冒泡，格式如下
void bubble_sort(void* base, int num, int size, int (*cmp)(const void*, const void*))
{
int i = 0;
//趟数
for (i = 0; i < num - 1; i++)
{
int j = 0;
//一趟内部比较的对数
for (j = 0; j < num - 1 - i; j++)
{
？？？？？？？？
}
}
}我们现在要解决的是？？？？？中需要解决的代码
而我们在定义函数bubble_sort时有一个函数指针为cmp，这个函数指针指向的就是一判断大小的函数；
函数cmp_int实现如下
int cmp_int(const void* p1, const void* p2)
{
return (*(int*)p1 - *(int*)p2);
}注意：博主这里进行的整型比较，所以强制转换的为整型。所转换类型由相应题而变化
这里，当p1>p2时返回1，所以我们可以进行以下设计
//假设需要升序cmp返回>0，交换
if (cmp((char*)base+j*size, (char*)base+(j+1)*size)>0)//两个元素比较，需要将arr[j],arr[j+1]的地址要传给cmp
{
//交换
Swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
}至于这里博主这里为什么要将base都强制转换成char*，是因为我们设计这个函数并不是为了只排序一种数组，而是要万能排序，char*占一个字节，作为一个基础单位，后面根据具体排序的数组类型再乘以该数组类型的长度进行遍历；
Swap是博主定义的用来进行交换的函数，实现如下
void Swap(char* buf1, char* buf2, int size)//交换arr[j],arr[j+1]这两个元素
{
int i = 0;
char tmp = 0;
for (i = 0; i < size; i++)
{
tmp = *buf1;
*buf1 = *buf2;
*buf2 = tmp;
buf1++;
buf2++;
}
}由于强制转换为了char*类型，所以不能直接交换，应一个一个交换，交换size次，原理如下图
完整实现代码如下
void Swap(char* buf1, char* buf2, int size)//交换arr[j],arr[j+1]这两个元素
{
int i = 0;
char tmp = 0;
for (i = 0; i < size; i++)
{
tmp = *buf1;
*buf1 = *buf2;
*buf2 = tmp;
buf1++;
buf2++;
}
}
void bubble_sort(void* base, int num, int size, int (*cmp)(const void*, const void*))
{
int i = 0;
//趟数
for (i = 0; i < num - 1; i++)
{
int j = 0;
//一趟内部比较的对数
for (j = 0; j < num - 1 - i; j++)
{
//假设需要升序cmp返回>0，交换
if (cmp((char*)base+j*size, (char*)base+(j+1)*size)>0)//两个元素比较，需要将arr[j],arr[j+1]的地址要传给cmp
{
//交换
Swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
}
}
}
}
int cmp_int(const void* p1, const void* p2)
{
return (*(int*)p1 - *(int*)p2);
}使用如下
void test3()
{
int arr[10] = { 3,1,5,2,4,7,9,6,8,0 };
int sz = sizeof(arr) / sizeof(arr[0]);
bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
}
int main()
{
test3();
return 0;
}关于结构体类型的排序，博主这里就不讲解了，代码如下
void Swap(char* buf1, char* buf2, int size)//交换arr[j],arr[j+1]这两个元素
{
int i = 0;
char tmp = 0;
for (i = 0; i < size; i++)
{
tmp = *buf1;
*buf1 = *buf2;
*buf2 = tmp;
buf1++;
buf2++;
}
}
void bubble_sort(void* base, int num, int size, int (*cmp)(const void*, const void*))
{
int i = 0;
//趟数
for (i = 0; i < num - 1; i++)
{
int j = 0;
//一趟内部比较的对数
for (j = 0; j < num - 1 - i; j++)
{
//假设需要升序cmp返回>0，交换
if (cmp((char*)base+j*size, (char*)base+(j+1)*size)>0)//两个元素比较，需要将arr[j],arr[j+1]的地址要传给cmp
{
//交换
Swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
}
}
}
}
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);
}
void test()
{
struct Stu arr[] = { {"zhangsan", 20}, {"lisi", 50},{"wangwu", 15} };
int sz = sizeof(arr) / sizeof(arr[0]);
printf("%d\n", sizeof(struct Stu));
bubble_sort(arr, sz, sizeof(arr[0]), cmp_stu_by_name);
}
int main()
{
test();
return 0;
}后续博主还会讲解关于指针和数组面试题的解析，想要了解的宝子们记得关注博主后续动态哦！
1506
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
