【C语言】指针详解（2）：数组与指针的关系

---

前言

本文首先论述了数组名的作用，再穿插介绍了二级指针、指针数组和数组指针变量的知识，在这些知识的基础上，我们用指针数组模拟实现了二维数组，还探讨了一维数组和二维数组传参的本质。

---

一、数组名的理解

数组名是有意义的，数组名是地址，而且是数组首元素的地址。 见如下示例：

#include <stdio.h>

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("%p\n", &arr[0]);
	printf("%p", arr);
	return 0;
}

我们发现数组名和数组首元素的地址打印出的结果⼀模⼀样，数组名就是数组首元素(第一个元素)的地址。

注： 数组名是数组⾸元素(第⼀个元素)的地址，但是有两个例外：

• sizeof(数组名)，sizeof中单独放数组名，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节
• &数组名，这里的数组名表示整个数组，取出的是整个数组的地址（整个数组的地址和数组首元素的地址属于不同类型的指针，使用时会有很大区别）

除此之外，任何地方使用数组名，数组名都表示数组首元素的地址。

下面看一个示例，观察arr和&arr在使用上的区别：

#include <stdio.h>

int main()
{
	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", &arr + 1);
	return 0;
}

这里我们发现&arr[0]和&arr[0]+1相差4个字节，arr和arr+1 相差4个字节，是因为&arr[0] 和 arr 都是首元素的地址，+1就是跳过⼀个元素。
但是&arr 和 &arr+1相差40个字节，这就是因为&arr是数组的地址，+1 操作是跳过整个数组的。

二、使用指针访问数组

在没有学习指针之前，我们都是采用数组名+数组下标的形式访问数组元素的。如下：

#include <stdio.h>

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);//这个表达式是用来求数组元素个数的。
	                                      //用到了sizeof(数组名),此处数组名表示整个数组。整个数组的大小/一个数组元素大小==数组元素个数
	int* p = arr;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);//数组名+数组下标的形式访问数组元素
	}
	return 0;
}

在学习了指针之后，我们就可以采用指针±整数再解引用的方式来访问数组元素。如下：

#include <stdio.h>

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	int* p = arr;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));//指针+-整数再解引用的方式访问数组元素
	}
	return 0;
}

看起来我们是使用了两种不一样的方式对数组元素进行访问，但其实在本质这两种访问数组的方式是完全等同的：

int*p = arr;//p是指针（地址），arr也是地址，我们也可以直接使用arr访问数组元素

printf("%d ", *(p + i));
printf("%d ", *(arr + i));
printf("%d ", arr[i]);//数组名+数组下标的访问形式在编译器处理的时候，也是转换成⾸元素的地址+偏移量求出元素的地址，然后解引⽤来访问的。

所以arr[ i ] 是完全等价于 *(arr+i)，同理将 *(p+i)换成p[ i ]也是能够正常打印的。

三、一维数组传参的本质

在学习指针之前，我们在数组传参时，会在形参部分用数组形式来接收这个参数，如下：

#include <stdio.h>

void test(int arr[])
{
	return;
}

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	test(arr);
	return 0;
}

但其实我们并不是真的在test()函数的形参部分创建了一个数组来接收参数，因为数组传参的本质是：在数组传参时，传递的是数组名，数组名是数组首元素的地址，也就是说本质上数组传参传递的是数组首元素的地址，所以函数形参的部分理论上应该使用指针变量来接收首元素的地址。

#include <stdio.h>

void test(int* p)
{
	return;
}

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	test(arr);//数组首元素是int类型，它的地址用int*的指针来接收
	return 0;
}

总结：⼀维数组传参，形参的部分可以写成数组的形式（但这只不过是为了方便理解而存在的一种形式，实际上形参部分的数组根本就没有真实创建），也可以写成指针的形式。

四、二级指针

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？ 答：存放在二级指针里 。

#include <stdio.h>

int main()
{
	int a = 10;
	int* pa = &a;//换一种写法，写成:int *pa(*pa代表这是一个指针，指向int类型的变量)
	int** paa = &pa;//paa就是一个二级指针。
	                //换一种写法来理解这个变量，写成:int* *paa(*paa代表这是一个指针，指向int*类型的变量)
	return 0;
}

对于⼆级指针的运算有：
（1） *ppa 通过对ppa中的地址进行解引用，这样找到的是 pa ， *ppa 其实访问的就是 pa .

int b = 20;
*ppa = &b;//等价于 pa = &b;

（2）**ppa 先通过 *ppa 找到 pa ,然后对 pa 进行解引用操作： *pa ，那找到的就是 a .

**ppa = 30;//等价于*pa = 30;等价于a = 30;

五、指针数组

什么是指针数组？
类比一下，整型数组是存放整型的数组，字符数组是存放字符的数组。所以指针数组就是存放指针的数组。
（1）整型数组和字符数组：

（2）整型指针数组和字符指针数组：

指针数组的每个元素都是用来存放指针（地址）的。指针数组的每个元素是地址，⼜可以指向⼀块区域。

六、指针数组模拟二维数组

#include <stdio.h>

int main()
{
	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数组中
	int* parr[3] = { arr1, arr2, arr3 };
	int i = 0;
	int j = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 5; j++)
		{
			printf("%d ", parr[i][j]);//等同于*(*(parr+i)+j);
		}
		printf("\n");
	}
	return 0;
}

parr[ i ]是访问parr数组的元素，parr[ i ]找到的数组元素指向了整型一维数组，parr[ i ][ j ]就是整型一维数组中的元素。
上述的代码模拟出二维数组的效果，实际上并非完全是⼆维数组，因为每一行并非是连续的。

七、数组指针变量

什么是数组指针变量？类比一下：
整型指针变量： int * pi; 存放的是整型变量的地址，能够指向整型数据的指针。
浮点型指针变量： float * pf; 存放浮点型变量的地址，能够指向浮点型数据的指针。
那数组指针变量应该是：存放的是数组的地址，能够指向数组的指针变量。

数组指针变量的形式如下：

int arr[10];//把数组名省略，剩下的就是这个数组的类型:int [10]

int (*p)[10];//这就是一个数组指针变量，可以存放int [10]类型的数组地址，指向⼀个大小为10个整型的数组
             //注意括号不能省去，（*p)保证*和p先结合，*p就代表它是指针，说明p是⼀个指针变量
             //要是省去括号，就变成:int* p[10]; p会先和[10]结合，就变成了一个整型指针数组
             //因为[]的优先级要⾼于*号的，所以必须加上（）来保证p先和*结合。

代码演示数组指针变量的使用：

#include <stdio.h>

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p1 = arr;//arr是数组首元素的地址，类型是int*
	int(*p2)[10] = &arr;//&arr取出的是整个数组的地址，类型是int(*)[10]

	printf("%p\n", *p2);//*p2相当于*&arr,解引用的效果和取地址效果是会相互抵消的，所以*&arr的结果就是arr
	                    //*p的结果就是arr，也就是数组首元素的地址，所以用%p形式打印
	printf("%d", **p2);//**p2相当于*arr，对数组首元素的地址解引用，就会得到数组首元素
	return 0;
}

八、二维数组传参的本质

在学习指针之前，我们有⼀个⼆维数组需要传参给⼀个函数的时候，我们是这样写的：

#include <stdio.h>

void test(int a[3][5], int r, int c)//形参写成了⼆维数组的形式
{
	int i, j;
	for (i = 0; i < r; i++)
	{
		for (j = 0; j < c; j++)
		{
			printf("%d ", a[i][j]);
		}
		printf("\n");
	}
}

int main()
{
	int arr[3][5] = { {1,2,3,4,5}, {2,3,4,5,6},{3,4,5,6,7} };
	test(arr, 3, 5);
	return 0;
}

这里实参是二维数组，形参也写成二维数组的形式，那还有什么其他的写法吗？

首先我们再次理解⼀下⼆维数组，二维数组其实可以看做是每个元素是⼀维数组的数组，也就是⼆维
数组的每个元素是⼀个⼀维数组。那么二维数组的首元素就是第一行，是个⼀维数组。

所以，根据数组名是数组首元素的地址这个规则，二维数组的数组名表示的就是第一行的地址，是一维数组的地址。根据数组指针中的知识，我们可以知道第一行的一维数组的类型就是 int [5] ，所以第一行的地址的类型就是数组指针类型 int(*)[5]。那就意味着⼆维数组传参本质上也是传递了地址，传递的是第一行这个⼀维数组的地址，那么形参也是可以写成指针形式的。

#include <stdio.h>

void test(int(*p)[5], int r, int c)//形参写成数组指针的形式
{
	int i, j;
	for (i = 0; i < r; i++)
	{
		for (j = 0; j < c; j++)
		{
			printf("%d ", p[i][j]);//相当于*(*(p+i)+j);
		}
		printf("\n");
	}
}

int main()
{
	int arr[3][5] = { {1,2,3,4,5}, {2,3,4,5,6},{3,4,5,6,7} };
	test(arr, 3, 5);
	return 0;
}

总结：⼆维数组传参，形参的部分可以写成数组形式（但这只不过是为了方便理解而存在的一种形式，实际上形参部分的数组根本就没有真实创建），也可以写成指针形式。

---