C++：征服C指针：指针(二)

上一篇文章我们介绍了：什么是指针，指针常见的问题，本篇我们主要介绍 ：指针与数组。

1. 指向数组的指针

1. int *p[n] : 指针数组， 它包括 n 个成员，每个成员都是一个指针，共有 5个指针 。 因为 [ ] 优先级高于 * ，相当于 int * (p[n]) .
2. int (*p)[n] : 指向数组的指针，它是一个指针，用来指向有 5个元素的数组
3. int *p = &array[0] : 指向数组初始元素的指针

💚💚💚 下面我用图来分析一下

![在这里插入图片描述](https://img-blog.csdnimg.cn/c8b8a49e3b134934904c69798101561d.png
💚 这里我重点分析下：指针数组 ： int *p[n] ， 看下 面代码

// 指针数组
void test_pointer_06_01()
{
	int (*p[5])[2];
	int element[2] = {1, 2};
	p[0] = &element;

	// 输出element 数组元素
	printf("element[0]: %d\n", (*p[0])[0]);  //1
	printf("element[1]: %d\n", (*p[0])[1]);  // 2 
	printf("p[0][0] address: %p\n", p[0][0]);  
	printf("element[0] address: %p\n", &element[0]);  
	printf("p[0][1] address: %p\n", p[0][1]);  
	printf("element[1] address: %p\n", &element[1]);  

	
	int element_2[2] = {3, 4};
	p[1] = &element_2;
	
	// element_2 数组元素
	printf("\n\nelement_2[0]: %d\n", (*p[1])[0]);  //3
	printf("element_2[1]: %d\n", (*p[1])[1]);  // 4
	printf("p[1][0] address: %p\n", p[1][0]);  
	printf("element_2[0] address: %p\n", &element_2[0]);  
	printf("p[1][1] address: %p\n", p[1][1]);  
	printf("element_2[1] address: %p\n", &element_2[1]);  
}
// 打印结果
element[0]: 1
element[1]: 2
p[0][0] address: 000000000061fdb8
element[0] address: 000000000061fdb8
p[0][1] address: 000000000061fdc0
element[1] address: 000000000061fdbc


element_2[0]: 3
element_2[1]: 4
p[1][0] address: 000000000061fdb0
element_2[0] address: 000000000061fdb0
p[1][1] address: 000000000061fdb8
element_2[1] address: 000000000061fdb4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

老规矩，还是上图比较清晰，直观

2. 多维数组

其实C中不存在多维数组，那些看起来像多维数组其实就是“数组的数组”。这个多维数组通常使用 hoge[i][j] 来访问。
我们还是通过一张图，来看看多维数组在内存中的布局。

💚💚💚

1. hoge 的类型为 “int 的数组(元素个数4个)的数组（元素个数3个）”。
2. 尽管如此，在表达式中数组可以被解读成 指针，因此，hoge的类型为 “指向int 数组（元素个数4）的指针”。
3. hoge[ i ] 是 *(hoge + i ) 的语法糖。
   1. 给指针加上 i , 意味着指针前进它指向的类型 （乘以 i ）的距离。 hoge指向的类型为 “int的数组（元素个数为4个）”，因此，hoge+i 让指针前进 ： sizeof(int[ 4 ] ) x i 的距离 。
   2. 通过 *(hoge + i )中的 星号 ， 去掉一个指针， （hoge + i）的类型就是指向 int 的数组（个数为4个）
   3. 尽管如此，由于在表达式中，数组可以解读成指针， （hoge + i）的最终类型为 “指向int 的指针” 。
   4. ((hoge + i ))[ j] 和 （((hoge + i) + j ）其实是相等的， 因此 ((hoge + i ))[ j] ： 就是“对指向 int 的指针 加上 j 后得到地址上 的内容”， 其类型为 int 。

三级目录