接上期文章指针进阶（1）指针进阶（1）
目录
1.函数指针
我们已经学过了数组指针，而数组指针是指向数组的指针。根据类比的思想，我们可以推测出函数指针是指向函数的指针。
那么，如何才能得到函数的地址呢？请看下面的代码：
程序输出的两个地址是相同的：
要想得到函数地址，可以使用&函数名或者直接函数名，使用%p的格式打印出来就可以了。
由此我们可知：
函数名是函数的地址
&函数名也是函数地址
如果想要将上面代码中函数的地址保存到指针变量中，那么这个指针的类型该如何书写呢？
测验：写出下面函数的函数指针类型
答案是：
注意：*pf的括号不能去掉，必须使*先和pf结合。
通过函数指针来调用该函数
下面代码是函数指针的调用方法：
int Add(int x, int y)
{
return x + y;
}
int main()
{
int(*pf)(int, int) = Add;
int r = Add(3, 5);
printf("%d\n", r);
int m = (*pf)(3, 5);
printf("%d\n", m);
int n = pf(3, 5);
printf("%d\n", n);
return 0;
}
打印结果：
通过上面的代码我们可以发现，pf前面的*可以省略，实际上，pf前面的*只是一个摆设，无论你加多少个*，都不会影响结果：
阅读两段有趣的代码：
代码一：
分析代码：
当然，我们写的程序是不能直接访问0地址的。
代码二：
分析代码：
2.函数指针数组
在前面，我们已经知道了将整型指针存放在一个数组中，那么这个数组就叫做整型指针数组，像：
int*arr[5] 就是一个整形指针数组。当然，还有我们比较熟悉的字符指针数组 char*arr[5] .
由此，我们可以推断出，函数指针数组就是数组的每个元素是函数指针类型。
为了学习函数指针数组，我们用一个实现两个整形数字计算的程序说起：
假设有这样一个计算器，它要实现两个整数的加法，减法，乘法，除法运算：
首先，我用写了下面这几个实现上述功能的函数：
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;
}可以看出，这四个函数的返回类型，参数个数，参数类型都是一样的，像这种同类型的函数就可以将函数地址存放在函数指针数组中。
关键是，这个函数指针数组该怎么写呢？我们一步一步的来写：
先写出能指向这四个函数的函数指针：
要想得到函数指针数组，只需要在上面代码的基础上修改：
得到数指针数组只需要在函数指针名字后面加上一个 [ ] 即可。
函数指针数组实际应用场景：
仍然以上面的计算器为例，下面是使用普通方法来写一个简单的计算器程序：
#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 meun()
{
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, y = 0;
int ret = 0;
do
{
meun();
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;
}使用普通方法来写代码，在switch语句中有非常多的重复部分。
下面对main函数进行修改（用到函数指针数组的方式）：
int main()
{
int input = 0;
int x = 0, y = 0;
int ret = 0;
//函数指针数组
int (*pfArr[5])(int, int) = { NULL,Add,Sub,Mul,Div };
//下标 0 1 2 3 4
do
{
meun();
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;
}
3.指向函数指针数组的指针
指向函数指针数组的指针这部分内容我们只需要了解即可，不需要深入研究。
在上面计算器的例子中，我们已经知道了函数指针数组的写法：
现在，我们想要写一个指针来指向这个函数指针数组，该怎么写呢？
只需要将数组名pfArr换成指针名p，在p的前面再加上一个*，并用括号括起来（[ ]的结合性比*高）
4.回调函数
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当 这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调 用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
就拿上面写过的计算器来举例子，我们把main()函数再次修改：
void calc(int(*pf)(int, int))
{
int x = 0, 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;
do
{
meun();
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("选择错误，重新选择:>");
break;
}
} while (input);
return 0;
}我们多增加了下面这个函数，这个函数的形参是一个函数指针，用来接收Add，Sub, Mul, Div等函数。当调用calc这个函数时，calc中又会根据形参传过来的函数地址调用这个函数。这就是函数回调。
程序的执行过程：
4.1qsort的用法
在标准库中，有一个函数叫qsort，是用来排序的，qsort适合于任意类型的数据排序。
compar的返回值所表示的内容：
void*类型的指针介绍
void*的指针是无具体类型的指针，这种指针是不能直接解引用的，也不能直接进行运算。但它可以接收任意类型的参数地址，使用前要进行强制类型转换。
void*指针接收任意类型的参数地址
使用qsort对数组进行排序
#include<stdio.h>
#include<stdlib.h>
int cmp_int(const void* p1, const void* p2)
{
return *(int*)p1 - *(int*)p2;
}
void Print(int arr[], int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", arr[i]);
}
}
void test1()
{
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);
Print(arr, sz);
}
int main()
{
test1();
return 0;
}使用qsort对结构体进行排序：
需要通过调试来观察数组的变化
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
//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;
}
int cmp_stu_by_name(const void* p1, const void* p2)
{
return strcmp(((struct stu*)p1)->name, ((struct stu*)p2)->name);
}
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_name);
}
int main()
{
test2();
return 0;
}
4.2使用冒泡排序算法模拟实现qsort
由于没有想学习快速排序算法，所以我们使用冒泡排序的思想，实现一个功能类似qsort的函数。
要点：
1.使用冒泡排序算法的思想
2.适用于任意数据类型的排序
要解决实现对任意类型数据的排序，我们接收数组的指针应该使用void*类型。
当我们排序整形时，我们可以直接进行比较，但当我们如果要进行结构体大小比较时，就不能直接比较了，这里需要用户自己写一个比较函数来进行比较。在排序算法中以函数参数的形式传递用户写的比较函数。
在整形数组中，可以直接通过数组下标来访问数组元素，但在我们自己写的排序函数中，我们使用的void*的指针类型，无法通过下标来访问。我们可以用下面的方式得到数组每个元素的地址：
不同的数据类型交换略有差异，原因是在排序函数中不知道该数据的类型，同时也是使用void*的指针接收的地址。但是，我们是知道每个元素的字节大小的，我们只需要一字节一字节交换，交换size次，就可以实现交换功能了：
代码实现交换：
接下来看看完整的实现代码吧：
//交换
void swap(char* buf1, char* buf2, int size)
{
int i = 0;
for (i = 0; i < size; i++)
{
char 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++)
{
if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
{
//交换
swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
}
}
}
}这篇博客就到这里结束了，下篇博客将继续学习指针，下篇博客是指针的最后一篇了，将会有大量有关指针面试题的总结，欢迎大家阅读与点赞~~