对（一维）数组与指针的深入理解（1）【超详细建议收藏】

1.数组名的理解

以前我们在使用指针访问数组内容时，有这样的代码：

#include <stdio.h>

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

这里我们使用 &arr[0] 的方式拿到了数组第一个元素的地址，但是数组名本身就是首元素地址，我们来进行测试：

#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      = %p\n", arr);

	return 0;
}

输出结果：

我们发现数组名和数组首元素的地址打印出来一模一样，数组名就是数组首元素（第一个元素）的地址。

那么下面的代码会让大家产生疑惑：

#include <stdio.h>

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

	printf("%zd\n",sizeof(arr));

	return 0;
}

输出结果：

如果arr是首元素地址，那么在32位/64位平台下的地址大小应该是4/8个字节，但是这里是40个字节，这又该怎么解释呢？

其实数组名就是首元素地址是对的，但是有两个例外：

• sizeof(数组名）
  sizeof中单独放数组名，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节。
• &数组名
  这里的数组名表示的是整个数组，取出的是整个数组的地址（整个数组的地址和数组首元素地址是有区别的）

除上述两种情况外，任何地方使用数组名，数组名都表示首元素地址。

我们再试一下这个代码：

int main()
{
   
	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);


	return 0;
}

输出结果：

三个打印出来的值都一模一样，这下我们又迷了，arr和&arr到底有啥区别呢？

接下来再来试试这个代码：

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\n", &arr + 1);


	return 0;
}

输出结果：

我们可以发现&arr[0]和arr 加1都相差4个字节，是因为&arr[0]和arr都是首元素地址，+1就是跳过一个元素，这里的元素是整型。

但是&arr和&arr+1相差了40个字节，这就是因为&arr是整个数组的地址，+1跳过的是整个数组。

画图演示：

这样我们就理解了arr与&arr的区别。

2.使用指针访问（一维）数组

有了前面的知识以及数组的特点，我们就可以使用指针访问数组了。

我们能够使用指针访问数组主要基于以下两个原因：

1. 数组在内存中是连续存放的。
2. 指针±整数运算，方便我们获得每一个元素的地址

int main()
{
   
	int arr[10] = {
    0 };
	//使用指针来访问数组
	int sz = sizeof(arr) / sizeof(arr[0]);

	//输入10个值
	int* p = arr;
	int i = 0;
	for (i = 0; i < sz; i++)
	{
   
		//输入一个值
		scanf("%d", p + i);// p+i == &arr[i]
	}

	//输出10个值
	for (i = 0; i < sz; i++)
	{
   
		printf("%d ", *(p + i));
	}

	return 0;
}

输出结果：

其实上述代码中的第13行与第19行可以进行变更修改：

这里由读者自行写代码试验。

3.（一维）数组传参的本质

要讨论（一维）数组传参的本质，我们可以先从一个问题开始，我们之前都是在函数外部计算数组的元素个数，那我们可以把数组传给一个函数后，在函数内部求数组的元素个数吗?

代码1：在函数外求元素个数

void print(int arr[], int sz)
{
   
	int i = 0;
	for (i = 0; i < sz; i++)
	{
   
		printf("%d ", arr[i]);
	}
}

int main()
{
   
	int arr[10] = {
    1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	print(arr, sz);

	return 0;
}

输出结果：

代码2：在函数内求元素个数

void print(int arr[])
{
   
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
   
		printf("%d ", arr[i]);
	}
}

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

	return 0;
}

输出结果：

从输出结果我们可以知道，在函数内外计算元素个数的两个程序运行的结果不同，代码2明显与我们的预期结果不相符，这是为什么呢？

要检查哪里出了问题，我们可以对代码2进行调试：

经过调试，我们发现了当程序执行到print函数计算sz时，结果并不是数组的元素个数10，而是1，所以for循环只执行一次，打印输出结果为1。

为什么sz=1呢？这是我们要思考的地方。

原因是因为主函数中print(arr)中的arr数组名就是数组首元素的地址，当我们实参传入arr时，实参本质上是用指针变量接收的，所以print函数我们也可以定义成：

void print (int * p)//这里应该是指针
{
   

}

所以数组传参的时候，形参是可以写成数组形式的，但是本质上还是指针变量。
所以代码2中sizeof（arr)实际上计算的是一个指针变量的大小，在x86环境下大小为4，而一个元素的大小也是4，所以相除得sz=1。

综上所述，我们可以知道：

1. 数组传参的本质是传递了数组首元素的地址，所以形参访问的数组和实参的数组是同一个数组。
2. 形参的数组是不会单独再创建数组空间的，所以形参的数组可以省略掉数组的大小。