C语言 之 理解指针（3）

本章主要内容是对数组名的理解、使⽤指针访问数组、⼀维数组传参的本质、⼆级指针、指针数组、指针数组模拟⼆维数组

1. 数组名的理解

在我们前面对指针有一定了解之后，如果我们想要获取数组的首元素地址，我们是不是会这么写呢？

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

用&运算符来获取第一个元素的地址，虽然这没有问题，但是其实没有必要，因为数组名本身就是首元素地址，注意，是首元素地址。

你要是不行你就来看看吧！

#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;
}
1
2
3
4
5
6
7
8

上面的代码都是打印一个地址，但一个参数是&arr[0]，一个参数是arr。但是打印的地址是相同的。

所以可以证明：数组名就是数组⾸元素(第⼀个元素)的地址

那么，难道数组名都表示数组首元素地址吗？当然不是。
来看看下面这个例子：

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

之前提到sizeof是计算元素大小的一个操作符，如果这里的arr代表的是一个数组的首元素，那么计算的大小应该是 4/8 ，但是结果却是40。

其实数组名表示首元素地址确实是没问题的，不过有两个特殊情况。

sizeof(数组名)： 在sizeof中单独放数组名，这里的数组名表示的就是整个数组，计算的是整个数组的大小，单位是字节。所以上面的例题计算的就是整个数组的大小。

&数组名： 此处的数组名表示整个数组，取出的是整个数组的地址（整个数组的地址和数组⾸元素的地址是有区别的），因为这意味着地址+1所需要跳过的字节数不同。

可以参考下面的例子：

#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\n", &arr + 1);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

从输出结果我们可以看到，&arr[0]、arr、&arr的首元素地址相同，但是+1后，前面两个都是跳过4个字节，而后面一个是跳过40个字节，这说明了这里的arr代表的是整个数组。

所以除了这两个特殊情况之外，其它的数组名都是代表首元素地址。

2. 使用指针访问数组

如果我们想用指针访问数组元素，那我们会这样写：

#include <stdio.h>
int main()
{
	int arr[10] = { 0 };
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]); //整个数组/数组中的一个元素 = 元素个数
	int* p = arr; //获取首元素地址
	for (i = 0; i < sz; i++)
	{
		scanf("%d", p + i);
		//scanf("%d", arr+i);//也可以这样写
	}
	for (i = 0; i < sz; i++)
	{
		printf("%d ", *(p + i));  //将要修改处
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

这里我们可以看到，int* p = arr; 所以p == arr，而对数组访问时我们通常会写成arr[i]进行访问，那么我们能不能用p[i]来对数组进行访问呢？

我们将上面代码中的printf("%d ", *(p + i));换成printf("%d ", p[i]);

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

我们发现，这样也是可以正常运行的。所以我们可以得出结论：*(p + i)和p[i]效果是相同的。那么同样的道理arr[i] 应该等价于 * (arr+i)

其实，数组元素的访问在编译器处理的时候，也是转换成首元素的地址+偏移量求出元素的地址，然后解引⽤来访问的。

3. 一维数组传参的本质

假如我们自定义了一个函数需要知道数组的元素个数，一般情况我们都是在外部计算好函数个数之后再把以参数的方式传递给它。那我们可以把珍格格数组传给这个函数，然后在函数内部求数组的元素个数吗？

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

结果是并不可以

我们前面说过，数组名是数组首元素地址，那么在数组传参的时候，传递的是数组名，也就是说本质上数组传参本质上传递的是数组首元素的地址。

所以函数形参的部分理论上应该使用指针变量来接收首元素的地址。
所以在自定义函数的内部中的sizeof(arr)，计算的就是这个首元素地址的大小，而不是数组的大小，即4/8个字节。

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

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

64位机器下

总结：一维数组传参，形参的部分可以写成数组的形式，也可以写成指针的形式。接收的是首元素的地址。

4. 二级指针

指针变量也是变量，既然它是变量，那么它就有地址。一级指针储存变量的地址，而储存一级指针的地址的就叫作二级指针

例如：

#include <stdio.h>
int main()
{
	int a = 10;
	int* pa = &a;
	int** ppa = &pa;
	return 0;
}
1
2
3
4
5
6
7
8

画图表示就可以这样来表示：

二级指针的运算：
我们在上面的代码中已经定义了int** ppa = &pa;
我们知道int* pa = &a; 那么pa就是变量a的地址，* pa就是变量a的值
那么对于二级指针int** ppa = &pa;来说，ppa存放的就是指针变量pa的地址， ppa就是指针变量pa的值，即变量a的地址，而 **ppa就是变量a的值 *
即：

*ppa 通过对ppa中的地址进⾏解引⽤，这样找到的是 pa ， *ppa 其实访问的就是 pa

int a = 10;
*ppa = &a;//等价于 pa = &a
1
2

**ppa 先通过 *ppa 找到 pa ,然后对再 pa 进⾏解引⽤操作，即 *pa ，那访问到的就是 a

**ppa = 20;
//等价于*pa = 20;
//等价于a = 20;
1
2
3

5. 指针数组

指针数组是指针还是数组？ 这是很容易弄混的一个问题。

我们可以想一想：
整形数组是存放整形的数组
字符数组是存放字符的数组

那么指针数组应该就是存放指针的数组了，其本质就是一个数组。

这是整形数组和字符数组

而这是指针数组：
指针数组的每个元素都用来存放地址（指针）
而每个元素也都可以指向一块空间

6. 指针数组模拟二维数组

有了上面的指针数组，我们就可以通过指针数组来模拟实现二维数组了

例如：
使用指针数组实现一个3行5列的二维数组

#include <stdio.h>
int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 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]);
		}
		printf("\n");
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

上面代码中int* parr[3] = { arr1, arr2, arr3 };就是指针数组了，因为数组名是数组首元素的地址，所以这个数组指针就存放了arr1,arr2,arr3 这3个指针（地址）。再根据我们前面所学的* (p + i)和p[i]效果是相同的 这也适用与二维数组，所以就可以通过parr[i][j]来进行打印。

具体是怎么样的，就可以根据下图理解：

parr[i]先是访问parr数组的元素，parr[i]找到了其数组元素后指向了整型⼀维数组，parr[i][j]就是整型⼀维数组中的元素。

上述的代码虽然模拟出⼆维数组的效果，实际上并非完全是⼆维数组，因为每一行并非是连续存放的，而二维数组在空间中是连续存放的。