C语言：数组指针 & 函数指针
- 数组指针
- 数组名
- 数组访问
- 二维数组
- 函数指针
- 函数指针使用
- 回调函数
- typedef关键字
数组指针
数组本质上也是一个变量，那么数组也有自己的地址，指向整个数组的指针，就叫做数组指针。
我先为大家展示一个数组指针，再做数组指针的语法解析。
数组int arr[10]的指针：
int (*p)[10]
(*p)代表p是一个指针[10]代表这个指针指向的数组有10个元素int代表这个指针指向的数组元素类型为int
不能写成 int *p[10]：
[] 的优先级高于 *，所以p会先和 [] 结合，此时p就是一个数组变量了，而指向的元素类型为 int*。所以需要一个 () 来改变操作符的结合顺序，让 p 和 * 先结合，代表p是一个指针。
数组指针的类型就是去掉指针名剩下的部分，比如：
int (*p1)[10] = &arr1;
//p1的类型为：int (*)[10]char (*p2)[3] = &arr2;
//p2的类型为：char (*)[3]
数组名
学习指针后，其实我们的数组名就已经不单纯是一个数组名了，我们先来观察现象：
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
printf("&arr[0] = %p\n", &arr[0]);
printf("arr = %p\n", arr);
printf("&arr = %p\n", &arr);
输出结果：
&arr[0] = 009BFEB0
arr = 009BFEB0
&arr = 009BFEB0
可以看到，数组名本质上是地址，&数组名 也是地址，而且arr == &arr == &arr[0]，也就是说它们都是首元素的地址。
数组名的本质是首元素的地址
那么 数组名 与 &数组名 有什么区别吗？
我们再看一段代码：
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };printf("&arr[0] = %p\n", &arr[0]);
printf("&arr[0]+1 = %p\n", &arr[0]+1);printf("arr = %p\n", arr);
printf("arr+1 = %p\n", arr+1);printf("&arr = %p\n", &arr);
printf("&arr+1 = %p\n", &arr+1);
输出结果：
&arr[0] = 0077F820
&arr[0]+1 = 0077F824
arr = 0077F820
arr+1 = 0077F824
&arr = 0077F820
&arr+1 = 0077F848
这⾥我们发现&arr[0]和&arr[0]+1相差4个字节，arr和arr+1相差4个字节，是因为&arr[0]和arr都是⾸元素的地址，+1就是跳过⼀个元素。
但是&arr和&arr+1相差40个字节，这是因为&arr是数组的地址，+1操作是跳过整个数组的。
也就是说：
arr 本质是数组首元素的指针
&arr 本质是整个数组指针
但是有关数组名，也有特例：
sizeof(arr)，sizeof内单独放数组名，此时数组名表示整个数组，得到整个数组的大小
数组访问
现有如下数组：
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
现在我们以一般的方式来遍历这个数组：
for (int i = 0; i < 10; i++)
{printf("%d ", arr[i]);
}
由于数组的内存是连续存储的，我们也可以通过指针的方式来遍历这个数组：
int* p = arr;for (int i = 0; i < 10; i++)
{printf("%d ", *(p + i));
}
我们刚刚辨析过，arr本质就是首个元素的地址，所以int* p = arr;就是把第一个元素的地址交给指针p。在循环内部，我们通过指针偏移量i与首元素的指针p来定位元素，再解引用访问*(p + i)。这样就可以完成数组的遍历。
有没有发现，arr[i]与*(p + i)非常像，它们之间有没有什么联系？
arr的本质是首元素的指针，而p也是arr，那么我们可不可以用p代替arr进行下标访问？
比如这样：
int* p = arr;for (int i = 0; i < 10; i++)
{printf("%d ", p[i]);
}
答案是可以的，这就要讲一讲下标访问的本质了。
arr数组本质上是首元素的地址，通过第一个地址与偏移量，我们就可以访问到所有数组元素。而数组下标的本质就是指针偏移量。
而数组的下标访问，本质上也是指针的访问：
arr[i] == *(arr + i)
这条规则并不局限于数组名，任何指针都可以使用p[i]来替代*(p + i)的效果。
此外，由于加法支持交换律，所以 *(arr + i)与*(i + arr)是等效的，故有以下代码：
arr[i] == *(arr + i) == *(i + arr) == i[arr]
因为i[arr]最后会被解析为*(i + arr)，所以这个写法也是可以的。
二维数组
了解数组指针后，我们就可以深入理解二维数组的底层实现了。
其实二维数组的本质是存储一维数组的数组，二维数组的每一个元素都是一维数组。
接下来我们模拟实现一个二维数组：
int arr1[5] = { 1,2,3,4,5 };
int arr2[5] = { 2,3,4,5,6 };
int arr3[5] = { 3,4,5,6,7 };int* parr[3] = { arr1,arr2,arr3 };
我们一开始创建了三个一维数组arr1，arr2，arr3，然后创建了一个parr把前三个一维数组放进去了，此时我们就模拟实现了一个二维数组。即将三个一维数组放进了另外一个数组中，接下来我们用访问二维数组的方式parr[i][j]来进行访问：
for (int i = 0; i < 3; i++)
{for (int j = 0; j < 5; j++){printf("%d ", parr[i][j]);}printf("\n");
}
输出结果：
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
可以看到，我们确实可以用二维数组的方式去访问这个数组。
那么为什么可以这样操作呢？
重点在以下过程：
int* parr[3] = { arr1,arr2,arr3 };
我们真的把三个数组放在了这个parr数组里面吗？
我们先前讲过，数组名的本质是首元素的地址，也就是说这里的arr1，arr2，arr3只是三个地址而已，我们只是把三个地址存进了parr里面。
如图：
接下来我们解析一下parr[i][j]是如何定位到指定位置的。
对第一个索引值i：
通过前面的学习，我们知道parr的本质是外层数组的第一个元素，那么parr[i]就是*(parr + i)，此时就得到了下标为i的元素。而parr里存储的是数组指针，比如parr[0]得到第一个数组的指针，也就是arr1，parr[1]得到第一个数组的指针，也就是arr2。
所以我们可以通过第一个索引值i来定位数组。
对第二个索引值j：
既然parr[i]得到的是内部一维数组的指针，那parr[0][j]其实就是arr1[j]，parr[1][j]其实就是arr2[j]。这样事情就简单了，我们通过第一个索引值拿到了小数组的指针，接着再用一个索引值j来定位这个一维数组中的具体哪一个元素，就可以得到目标元素了。
以上只是一个模拟的二维数组，但是真实的二维数组还要复杂一些，接下来我们看看真实的二维数组是如何运作的：
看到以下代码：
int arr[3][5] = { {1,2,3,4,5}, {2,3,4,5,6}, {3,4,5,6,7} };for (int i = 0; i < 3; i++)
{for (int j = 0; j < 5; j++){printf("%p\n", &arr[i][j]);}printf("\n");
}
输出结果：
007AFAB8
007AFABC
007AFAC0
007AFAC4
007AFAC8007AFACC
007AFAD0
007AFAD4
007AFAD8
007AFADC007AFAE0
007AFAE4
007AFAE8
007AFAEC
007AFAF0
可以看到，这个二维数组的地址是完全连续的，不存在每一行之间存在间隔，两行之间也是紧密挨着的。
这是你想象的二维数组：
但是其在内存中是这样的：
那么其是如何运作的呢？
对于arrr[3][5]这个数组，其内部存储了三个数组（而不是三个数组的指针！），每个数组中存储了五个元素。
在刚刚的模拟实现中，我们是用外层parr数组存储了3个指针，这里存的就是真真正正的数组。这就是两者的区别。
那么我们这里的arr是什么类型？
arr是外层数组的数组名，数组名代表了第一个元素的指针，这里arr的第一个元素是一个数组：
这三个数组的类型是：int (*)[5]，所以二维数组的数组名arr的指针类型就是int (*)[5]。
接下来我们再对arr[i][j]这样的下标访问进行分析：
对第一个索引值i：
arr作为数组名，本身是一个指针，此指针的类型为int（*）[5]，类型决定步长，于是步长为int [5]类型数组的大小：20字节。在面对一个步长为20字节的指针，i的偏移量也就变成了20字节。
对第二个索引值j：
arr内存储的是步长为4字节的数组指针，解引用后，*（arr+i）这个整体就变成了一维数组的指针，其类型为int *，类型决定步长，于是步长为4字节，在面对一个步长为4字节的指针，j的偏移量就变成了4字节。
所以可以看到，此时的i和j是通过指针类型不同，进而影响指针的偏移量大小，对于i每个单位跳过二十字节，也就是一个数组的大小；对于j，每个单位跳过四字节，也就是一个元素的大小。先用i来确定元素在第几个数组，再用j来确定元素在这个数组的第几位，从而确定元素的位置。
函数指针
么是函数指针变量呢？
根据前⾯学习整型指针，数组指针的时候，我们的类⽐关系，我们不难得出结论：
函数指针变量应该是⽤来存放函数地址的，未来通过地址能够调⽤函数的。
那么函数是否有地址呢？
做一个测试：
void test()
{printf("hehe\n");
}
int main()
{printf("test: %p\n", test);printf("&test: %p\n", &test);return 0;
}
输出结果：
test: 005913CA
&test: 005913CA
确实打印出来了地址，所以函数是有地址的，函数名就是函数的地址，当然也可以通过 &函数名 的⽅式获得函数的地址。
如果我们要将函数的地址存放起来，就得创建函数指针变量咯，函数指针变量的写法其实和数组指针⾮常类似。
我先为大家展示一个函数指针，再做指针的语法解析。
函数void Add(int x, int y)的指针：
void (*p) (int, int)
(*p)代表p是一个指针(int , int y)代表这个指针指向的函数有两个int类型的参数void代表这个指针指向的函数返回值为void
函数指针有以下注意点：
函数的参数名可有可无：
void (*p) (int, int);
void (*p) (int x, int y);
两者效果是一致的
函数名 与 &函数名 没有区别
在数组中，arr与&arr是有区别的，但是函数中，两者效果一致。
函数指针使用
想要使用函数的指针，那就是：先解引用指针，再调用函数。
void (*p) (int, int) = &Add;(*p)(2, 3);//完成2 + 3 的加法
void (*p) (int, int) = &Add;首先定义了一个指向Add函数的指针p。
我们获得指针后，要先解引用(*p)，然后调用函数(*p)()，再传入参数(*p)(2, 3)。
这样我们就完成了函数的调用。
但是，Add函数名本质上也是一个函数指针，为什么Add(2, 3)可以直接调用函数，而不用解引用呢？
ANSIC标准规定：函数指针中，p()是(*p)()的简写。
也就是说在调用函数时，可以减少解引用这个步骤。
因此以上代码也可以写成：
void (*p) (int, int) = &Add;p(2, 3);//完成2 + 3 的加法
另外的，对于函数指针，解引用*是没有意义的，所以我们有以下通过指针调用函数的方法：
p(2, 3);//省略*
(*p)(2, 3);//不省略*
(**p)(2, 3);//有多余的*
(***p)(2, 3);//有多余的*
//......
(**********p)(2, 3);//有多余的*
你不论解引用多少次，最后都可以正常调用函数。
回调函数
回调函数就是⼀个通过函数指针调⽤的函数。
如果你把函数的指针（地址）作为参数传递给另⼀个函数，当这个指针被⽤来调⽤其所指向的函数时，被调⽤的函数就是回调函数。
下面是一个简单的例子来说明回调函数的使用：
// 回调函数的定义
void callback(int num)
{printf("回调函数被调用，传递的参数为: %d\n", num);
}// 接受回调函数作为参数的函数
void performCallback(void (*func)(int)){printf("执行回调函数之前的操作\n");func(10);
}int main(){// 主函数中调用接受回调函数的函数performCallback(callback);return 0;
}
在上面的例子中，我们定义了一个名为callback的回调函数，它接受一个整数作为参数，并在函数体内输出这个参数的值。然后我们定义了一个名为performCallback的函数，它接受一个函数指针作为参数。在performCallback函数中，我们先输出一些操作，然后调用传递进来的函数指针，并传递一个整数参数10，最后再输出一些操作。在主函数中，我们调用performCallback函数，并将callback函数作为参数传递进去。
运行这个程序，输出如下：
执行回调函数之前的操作
回调函数被调用，传递的参数为: 10
可以看到，performCallback函数在执行之前和之后都执行了一些操作，并在中间调用了传递进来的回调函数callback，并将参数10传递给它。
typedef关键字
typedef关键字用于对变量重命名。
用法如下：
typedef unsigned int uint;
将unsigned int 重命名为 uint，后续可以使用uint代替 unsigned int，比如这样：
uint x = 5;
此时的x变量就是unsigned int类型了。
那为什么我要在指针这里讲typedef关键字呢？
因为对于指针，其有不太一样的语法。
对于一般的指针，直接重命名即可
将 int* 的指针重命名为 pint：
typedef int* pint;
普通指针的语法命名与一般的类型没有区别。
对于数组指针：
对于数组指针
如果根据一般的语法，重命名是：
typedef int (*) [5] parr;
将 int (*) [5] 这个数组指针重命名为 parr
但是数组指针不允许这样命名，必须把新的名称放在
*的旁边
typedef int (*parr) [5];
这样才算把 int (*) [5] 这个数组指针重命名为 parr。
对于函数指针：
和数组指针同理，不允许按照一般的语法重命名，要把名称放在*旁边：
将void (*) (int)类型的指针重命名为pfunc
错误案例：
typedef void (*) (int) pfunc;
正确示范：
typedef void (*pfunc) (int);
