前言

上一篇《细说C指针》第7部分中简述了指针和数组的简单用法。
这篇着重探讨一下指针和数组之间的各种复杂关系。

1、先说说数组名

数组名很容易让初学者困惑, 它到底是指针还是数组? 怎么有时候当数组用, 有什么当指针用? 查阅了各种资料, 得出的结论:
数组名是一个指针常量, 指向数组首元素的地址, 其数据类型取决于数组元素的类型。
但有2种场合, 数组名并不被编译器当做指针常量来处理:

• sizeof(arrName) 返回整个数组的长度, 而不是指针常量的长度。
• &arrName 对数组名取址返回的是指向数组的指针, 而不是指向指针常量的指针。

举例说明:
注: 例中的type就是基本数据类型, 如 int, float, char等等; N是int常量。

type arr[];
普通数组的元素类型是 type类型, 那么数组名的类型就是 指向type类型变量的指针类型, 即 type *。

type *arr[];
指针数组的元素类型是 指向type类型变量的指针类型, 那么数组名的类型就是 二级指针, 即type **。

type arr[][N];
二维数组的元素类型是 数组类型, 那么数组名的类型就是 指向数组的指针(数组指针), 即 type (*)[N]。

画个表格可能直观点:

image.png

2、指针与一维数组

int array[N]; // 一维数组, N为int常量

array 是数组名, 是指向数组首元素地址的指针常量, 其数据类型是int *, 因为是指针常量, 所以不可再指向别的存储单元。(这点在上篇文章《细说C指针》中有说明)
&array 是指向整个数组的指针常量, 也就是数组指针, 其数据类型是 int (*)[N]; 因为是指针常量, 所以让&array指向其他数组是非法的。

可以定义一个数组指针变量p指向这个数组的地址:

int (*p)[N] = &array;

这跟下面两句代码的语法类似:

const int i = 0;
const int *pi = &i;

由于数组名是指针常量, 也就意味着不能改变指针指向, 也不能通过自增自减来访问数组元素, 为了方便使用, 可以定义与数组名相同类型的指针变量并将数组名的地址值赋值给它。
举个栗子:

int arr[5] = {0, 2, 5, 8, 6};
int *p = arr;  // p具有arr的大部分性质, 可以用数组下标访问
int *p1 = {0, 2, 5, 8, 6}; // 也可以直接定义一个 int *类型的指针变量直接指向int数组

printf("%d--%d--%d--%d\n", *p, *p+1, *(p+1), p[2]); // 输出: 0--1--2--5
printf("%d--%d--%d--%d\n", *arr, *arr+1, *(arr+1), arr[2]); // 输出: 0--1--2--5
printf("%lu--%lu--%lu\n", sizeof(arr), sizeof(&arr[0]), sizeof(p)); // 输出: 20--8–8 &arr[0]就是个指向数组首元素的指针, 不等价于二维数组名arr
printf("%p--%p--%p--%p--%p\n", arr, &arr,  &arr[0], p, &p); // 输出: 0x7fff5fbff6e0--0x7fff5fbff6e0--0x7fff5fbff6e0--0x7fff5fbff6e0--0x7fff5fbff6c8

for (int i=0; i<5; i++) {
    printf("%p\n", p++);
} // 遍历输出数组每个元素的地址, 而arr++编译器就会报错

for (int i=0; i<5; i++) {
    printf("%d\n", *p++);
} // 遍历输出数组每个元素的值

int arr1[5] = {0, 2, 5, 8, 6};
arr = arr1; // Error
p = arr1; // 没毛病

从控制台打印输出可看出, 指针和数组名并不完全相同。下面以目前的理解, 总结出他们的异同供大家参考, 欢迎探讨补充。

共同点:

1. 都可以使用数组下标[]访问数组元素;
2. 都可以使用取值符*访问数组元素;
3. 大致可以归纳为: 取值运算中, 指针和数组名是等价的;

不同点:

1. 数组名被传入sizeof()函数, 实际输出的是数组的大小;
2. 指针指向了数组名也还是指针, 64位机器中就占8个字节;
3. 数组名被取址, 取到的是数组的地址, 这个地址与数组名、数组首元素的地址是同一个地址 (就好比省政府和市政府的意思, 如济南是一个地址, 山东的省政府在这个地址, 济南市的市政府也在这个地址);
4. 指针被取址, 取到的是指针变量本身的地址, 跟数组的地址一点关系也没有;
5. 数组名是常量, 不能被修改, 也就是不能再被赋值为其他数组, 也不能进行++、--的算术运算; 这也解释了为什么数组只有在初始化时才能被一次性赋值;
6. 指针若被定义为变量, 就可以修改指向, 也可以进行自增自减的算术运算;

3、指针与字符串:

字符串本质上就是char类型的一维数组, 因为字符串就是一堆char变量有序排列组成, 而数组就是用来存储这样的同种类型的有序数据, 所以可以使用数组来保存字符串。

// 字符串的初始化
char str1[] = "felix";
char str2[] = {'f', 'e', 'l',  'i',  'x', '\0'};
char str3[6] =  {'f', 'e', 'l',  'i',  'x'}; // felix0, 部分初始化中, 没有被初始化的元素默认是0, \0对应的ASCII是0。
char str4[3] = {'f', 'e', 'l',  'i',  'x'}; // 该方式不是字符串, 而是普通的字符数组, 字符串必须以\0结尾。
str2[1] = 'a'; // 字符串的本质就是数组, 可以通过脚标访问数组元素
printf("%s", str2); // 输出 falix  (%s的原理, 从传入的"地址"开始逐个取出, 直到遇到"\0"位置)

既然字符串就是数组, 数组名str1就是指向字符串的首字符的地址的指针常量。
就可以将str1赋值给相同类型的指针变量
char *sp1 = str1;
// 也可以直接定义一个char *类型的指针变量指向某个字符串(同一维字符数组)
char *sp2 = "felix";

4、指针与二维数组

先简单介绍一下二维数组:
二维数组本质上是以数组作为数组元素的数组, 即"数组的数组"

二维数组的声明形式:
类型说明符 数组名[常量表达式][常量表达式];

举栗说明:

int array[2][3] = {{1, 8, 6}, {5, 2, 0}};
二维数组是嵌套定义的, 这个二维数组就是由两个一维数组array[0]和array[1]组成的。

array[0][0] 是二维数组首元素的首元素, 即1, 是int类型。

array[0] 是第0个一维数组{1, 8, 6}的数组名; 是int *类型的指针常量。

array是二维数组名, 是指向二维数组首元素的地址的指针常量, 二维数组的首元素是一个一维数组; 指向数组的指针叫数组指针, 那么array就是一个数组指针常量, 其类型是int(*)[3]。

&array 是对二维数组名取址, 得到的是指向二维数组的指针常量, 其类型是int (*)[2][3]; 

&array[0] 对第0个一维数组取址, 得到指针指向及类型都与array相同的指针常量, 但它只是一个指针, 没有数组名的性质。sizeof(&array[0]) == 8; 而sizeof(array)) == 24;

*array 是对二维数组首元素的地址取值, 得到的就是array[0], 也就是说*array完全等价于array[0]。
*(array+1) 等价于 array[1]。array的增量以其所指向的一维数组的长度为单位。

**array 就是 *array[0], 也就是 array[0][0], 即1。

像一维数组一样, 我们也可以定义一个与数组名相同类型的指针变量, 并将数组名的地址值赋值给它。注意定义指针变量时, 必须标明指针所指向的一维数组的容量, 否则导致一些错误。

int array[2][3] = {{1, 8, 6}, {5, 2, 0}};
int (*pa)[3] = array; // 此时pa的增量以它所指向的一维数组的长度为单位; 

printf("%d--%d--%d--%d\n", array[0][0], pa[0][0], **array, **pa); // 输出: 1--1--1--1
printf("%d--%d--%d--%d\n", *(*array+1), *(*pa+1), (*array)[1], (*pa)[1]); // 输出: 8--8--8--8
printf("%d--%d--%d--%d\n", *(*(array+1)+1), *(*(pa+1)+1), (*(array+1))[1], (*(pa+1))[1]); // 输出: 2--2--2--2
printf("%d--%d--%d--%d\n", **(array+1), *array[1], **(pa+1), *pa[1]); // 输出: 5--5--5--5

printf("%lu--%lu\n", sizeof(*array), sizeof(array[0])); // 输出: 12--12, 正是一维数组的长度
printf("%p--%p\n", *array, array[0]); // 输出: 0x7fff5fbff6e0--0x7fff5fbff6e0

printf("%lu--%lu\n", sizeof(*(array+1)), sizeof(array[1])); // 输出: 12--12
printf("%p--%p\n", *(array+1), array[1]); // 输出: 0x7fff5fbff6ec--0x7fff5fbff6ec 刚好比6e0高了12字节, 正是一维数组的长度

printf("%p--%p--%p--%p--%p\n", &array, array, &array[0], array[0], &array[0][0]); // 全部: 0x7fff5fbff6e0

printf("%lu\n", sizeof(array)); // 24 二维数组长度
printf("%lu\n", sizeof(&array[0])); // 8 &array[0]就是个指向二维数组首元素的指针, 不等价于二维数组名array

// 分析:
// 在取值运算中, 指针pa和数组名array完全等价, 前面说了, *array就是array[0], 所以有:
// *array == array[0] == *p == p[0]
// pa和array的增量以其指向的一维数组的长度为单位, 所以:
// *(array+1) == array[1] == *(pa+1) == pa[1]