---

数组指针

数组本质上也是一个变量，那么数组也有自己的地址，指向整个数组的指针，就叫做数组指针。

我先为大家展示一个数组指针，再做数组指针的语法解析。
数组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
007AFAC8

007AFACC
007AFAD0
007AFAD4
007AFAD8
007AFADC

007AFAE0
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);

---