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. 形参的数组是不会单独再创建数组空间的，所以形参的数组可以省略掉数组的大小。