C语言 指针(4)

目录

1.数组名的理解

2.使用指针访问数组

3.一维数组传参的本质

---

1.数组名的理解

在上一个章节我们在使用指针访问数组的内容时，有这样的代码：

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

这里我们使用 &arr[0] 的方式拿到了数组第一个元素的地址，但是其实数组名本来就是地址，而且

是数组首元素的地址，我们来做个测试。

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

输出结果:

&arr[0] = 004FF9CC
arr     = 004FF9CC

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

的地址。
 
如果数组名如果是数组首元素的地址，那下面的代码怎么理解呢？

1 #include <stdio.h>
2 int main()
3 {
4     int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
5     printf("%d\n", sizeof(arr));
6     return 0;
7 }

输出的结果是：40，如果arr是数组首元素的地址，那输出应该的应该是4/8才对。
 
其实数组名就是数组首元素(第一个元素)的地址是对的，但是有两个例外：
 
-  sizeof(数组名) ，sizeof中单独放数组名，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节

-  &数组名 ，这里的数组名表示整个数组，取出的是整个数组的地址（整个数组的地址和数组首元素的地址是有区别的）
 
除此之外，任何地方使用数组名，数组名都表示首元素的地址。
 
这时有好奇的同学，再试一下这个代码：

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

三个打印结果一模一样，这时候又纳闷了，那arr和&arr有啥区别呢?

1 #include <stdio.h>
2 int main()
3 {
4     int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
5     printf("&arr[0]  = %p\n", &arr[0]);
6     printf("&arr[0]+1 = %p\n", &arr[0]+1);
7     printf("arr      = %p\n", arr);
8     printf("arr+1    = %p\n", arr+1);
9     printf("&arr     = %p\n", &arr);
10    printf("&arr+1   = %p\n", &arr+1);
11    return 0;
12 }

输出结果:

1 &arr[0]   = 0077F820
2 &arr[0]+1 = 0077F824
3 arr       = 0077F820
4 arr+1     = 0077F824
5 &arr      = 0077F820
6 &arr+1    = 0077F848

这里我们发现&arr[0]和&arr[0]+1相差4个字节，arr和arr+1相差4个字节，是因为&arr[0]和arr都

是首元素的地址，+1就是跳过一个元素。
 
但是&arr和&arr+1相差40个字节，这就是因为&arr是数组的地址，+1操作是跳过整个数组的。
 
到这里大家应该搞清楚数组名的意义了吧。
 
数组名是数组首元素的地址，但是有2个例外。

2.使用指针访问数组

有了前面知识的支持，再结合数组的特点，我们就可以很方便的使用指针访问数组了。

1 #include <stdio.h>
2 int main()
3 {
4     int arr[10] = {0};
5     //输入
6     int i = 0;
7     int sz = sizeof(arr)/sizeof(arr[0]);
8     //输入
9     int* p = arr;
10    for(i=0; i<sz; i++)
11    {
12        scanf("%d", p+i);
13        //scanf("%d", arr+i);//也可以这样写
14    }
15    //输出
16    for(i=0; i<sz; i++)
17    {
18        printf("%d ", *(p+i));
19    }
20    return 0;
21 }

这个代码搞明白后，我们再试一下，如果我们再分析一下，数组名arr是数组首元素的地址，可以

赋值给p，其实数组名arr和p在这里是等价的。那我们可以使用arr[i]可以访问数组的元素，那p[i]是

否也可以访问数组呢?

1 #include <stdio.h>
2 int main()
3 {
4     int arr[10] = {0};
5     //输入
6     int i = 0;
7     int sz = sizeof(arr)/sizeof(arr[0]);
8     //输入
9     int* p = arr;
10    for(i=0; i<sz; i++)
11    {
12        scanf("%d", p+i);
13        //scanf("%d", arr+i);//也可以这样写
14    }
15    //输出
16    for(i=0; i<sz; i++)
17    {
18        printf("%d ", p[i]);
19    }
20    return 0;
21 }

在第18行的地方，将 *(p+i) 换成 p[i] 也是能够正常打印的，所以本质上 p[i] 是等价于 *(p+i) 。
 
同理 arr[i] 应该等价于 *(arr+i) ，数组元素的访问在编译器处理的时候，也是转换成首元素的地址

+偏移量求出元素的地址，然后解引用来访问的。

3.一维数组传参的本质

数组我们学过了，之前也讲了，数组是可以传递给函数的，这个小节我们讨论一下数组传参的本

质。
 
首先从一个问题开始，我们之前都是在函数外部计算数组的元素个数，那我们可以把数组传给一个

函数后，函数内部求数组的元素个数吗?

1 #include <stdio.h>
2 
3 void test(int arr[])
4 {
5     int sz2 = sizeof(arr)/sizeof(arr[0]);
6     printf("sz2 = %d\n", sz2);
7 }
8 
9 int main()
10 {
11     int arr[10] = {1,2,3,4,5,6,7,8,9,10};
12     int sz1 = sizeof(arr)/sizeof(arr[0]);
13     printf("sz1 = %d\n", sz1);
14     test(arr);
15     return 0;
16 }

输出结果:

sz1 = 10
sz2 = 1

我们发现在函数内部是没有正确获得数组的元素个数。
 
这就要学习数组传参的本质了，上个小节我们学习了: 数组名是数组首元素的地址；那么在数组传

参的时候，传递的是数组名，也就是说本质上数组传参传递的是数组首元素的地址。
 
所以函数形参的部分理论上应该使用指针变量来接收首元素的地址。那么在函数内部我们

写 sizeof(arr) 计算的是一个地址的大小（单位字节）而不是数组的大小（单位字节）。正是因为函

数的参数部分是本质是指针，所以在函数内部是没办法求的数组元素个数的。

1 void test(int arr[])//参数写成数组形式，本质上还是指针
2 {
3     printf("%d\n", sizeof(arr));
4 }
5
6 void test(int* arr)//参数写成指针形式
7 {
8     printf("%d\n", sizeof(arr));//计算一个指针变量的大小
9 }
10 int main()
11 {
12     int arr[10] = {1,2,3,4,5,6,7,8,9,10};
13     test(arr);
14     return 0;
15 }

总结: 一维数组传参，形参的部分可以写成数组的形式，也可以写成指针的形式。