指针之旅（3）—— 指针与数组

1. 数组名的两种意义

2. 指针访问数组（指针也能下标引用）

3. 一维数组传参的本质和 sizeof在函数中失效的原因

4. 指针数组

4.1 指针数组的概念

4.2 一级指针数组

4.3 一级指针数组模拟实现二维数组

5. 数组、指针与字符串

6. 数组指针(变量)

6.1 数组指针的概念

6.2 一维数组指针(变量)

6.3 行指针(变量)

7. 二维数组传参的本质

1. 数组名的两种意义

数组名在三种不同的情况下共有2种意义：

❶数组名代表首元素【一种】

❷数组名代表整个数组【两种】

情况1 ---- 一般情况：数组名就是数组⾸元素的地址

情况2 ---- sizeof 数组名或 sizeof(数组名)：sizeof中单独放数组名时，这⾥的数组名表示整个数组，计算的是整个数组的大小，单位是字节。

情况3 ---- &数组名：此时数组名表示整个数组，取出的是整个数组的地址（整个数组的地址和数组⾸元素的地址是有区别的）

虽然说数组名有2种意义，但是我们又发现有这样一个等价式：

数组名的值 == 整个数组的地址 == 数组首元素的地址

即：arr == &arr == &arr[0]

那到底arr，&arr和&arr[0]有什么区别呢？让我们看一下下面的代码：

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的变化与 &arr[0]的变化是一样的，加1后都是相差了4个字节(1个int型)，这也侧面说明了在一般情况下，数组名就是数组⾸元素的地址。而&arr加1前后相差了40个字节(1个int[10]型)，而该数组arr的数据类型就是int[10]型，所以“&数组名”代表的是整个数组。

【没错，数组也是有数据类型的，详细请看《数组基础知识和冷知识（超详细总结）》中的“一维数组数据类型(需知)”和“二维数组数据类型(需知)”的知识点内容】

前面提到，sizeof中单独放数组名时，数组名才代表整个数组。所以如果sizeof中不仅仅只有数组名时，此时数组名还是代表首元素。

比如：

sizeof中的是arr+1，不是单独1个arr，所以此时的arr属于一般情况：arr等于&arr[0]。而arr[0]的数据类型是int型，是4个字节，根据“指针+-整数”的运算规则(即“地址+-整数”的规则)，+1等于加上4个字节，所以sizeof(arr+1)的结果是8。

2. 指针访问数组（指针也能下标引用）

在指针之旅(1)中，我们就学过解引用操作符*的知识了。

如果写一个程序来打印数组元素，要求使用指针访问数组，我们会这样写：

int main()
{int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };int sz = sizeof(arr) / sizeof(arr[0]);//输出int* p = arr;for (int i = 0; i < sz; i++){printf("%d ", *(p + i));}return 0;
}

而在指针之旅(1)中，我们也学过：我们对数组arr进行下标引用，其实在计算机中会自动转换成解引用操作，即arr[i]会先被计算机解读成*(arr+i)。

那我们能不能反其道而行，用指针p访问数组时写成p[i]呢？：

可以看到是可以这样操作的。于是就有了下面的等式：

*(p + i) == arr[i] == *(arr + i) == p[i]

3. 一维数组传参的本质和 sizeof在函数中失效的原因

在《函数(子程序)的常见、易混淆概念详解》中，我们学习了一维数组传参的本质：

一维数组传参的时候，本质上传递的是一维数组首元素arr[0]的地址，即&arr[0]。
函数形参数组是一个伪(一维)数组，本质上是一个一级指针。

正因为它是个指针，所以sizeof对形参数组计算出来的结果是指针的大小(4或8个字节)，而不是数组的大小。

代码举例：

4. 指针数组

4.1 指针数组的概念

指针数组是指针还是数组？

我们类⽐⼀下，整型数组，是存放整型的数组，字符数组是存放字符的数组。 所以指针数组是存放指针的数组。

指针数组的定义标准：

如果数组中每个元素都是用来存放同级别地址或指针的，那么该数组是一个指针数组。

代码举例：

int main()
{int a = 1, b = 2;int* pi = NULL;int* arr[5] = { &a,&b,pi };return 0;
}

这里的(整型一级)指针数组，既装有地址，如arr[1]的&a和arr[2]的&b；又装有一级指针，如arr[3]的pi。剩下的元素默认初始化为0，即NULL。

对于整型数组和字符型数组，它们的每一个元素的类型是这样的：

而指针数组的每一个元素的类型是类似下面这样的：

4.2 一级指针数组

（多级指针数组不常用，这里只讲解一级指针数组）

一级指针数组的数据类型：

去掉数组名，就是一级指针数组的类型：
即“ 内置类型 * [数组大小] ”

例如：

int* arr[7]的类型就是int* [7]。

4.3 一级指针数组模拟实现二维数组

我们先设置一个正常的(整型)二维数组：

int main()
{//二维数组的创建int arr[3][5] = { {1,1,1,1,1}, {2,2,2,2,2}, {3,3,3,3,3} };//输出for (int i = 0; i < 3; i++){for (int j = 0; j < 5; j++)printf("%d ", arr[i][j]);printf("\n");}return 0;
}

该二维数组的打印结果：

现在我们用一个(整型一级)指针数组来模拟这个二维数组：

int main()
{//指针数组的创建int arr1[] = { 1,1,1,1,1 };int arr2[] = { 2,2,2,2,2 };int arr3[] = { 3,3,3,3,3 };int* parr[3] = { arr1, arr2, arr3 };//输出for (int i = 0; i < 3; i++){for (int j = 0; j < 5; j++)printf("%d ", parr[i][j]);printf("\n");}return 0;
}

该指针数组打印的结果：

可以看到，两次打印的结果是一样的，这就是指针数组模拟实现二维数组。

虽然模拟出来了，但是两者的内存分布是不一样的。

这是二维数组的分布情况：

二维数组内部是连续的空间，且数组名arr指向的是数组首元素arr[0][0]。

指针数组属于数组，所以parr中的每个元素都是连续，即parr[0]、parr[1]、parr[2]是连续的，但是arr1，arr2，arr3的内存是相互独立的。数组名parr指向的是数组首元素parr[0]。

5. 数组、指针与字符串

当我们想用一个载体来装载所需要的字符串时，我们有两种方法。一种是用字符数组装载，比如char str[5] = "abc"; 另一种是用字符型指针装载，比如char* p = "abc";

其实这两种装载方式本质上是不一样的

先说结论：

（1）以字符数组为载体保存字符串，该字符串是可改变的。（可变字符串）

（2）以字符指针为载体保存字符串，该字符串是不可被更改的。（常量字符串）

i. 字符数组与可变字符串

我们先看这个代码：

int main()
{char str[10] = "hello";printf("str原来是%s\n", str);str[2] = 'X';printf("str后来是%s\n", str);return 0;
}

运行结果：

可以看到，hello变成了heXlo。

如果是指针的话，会发生什么？

ii. 字符指针(变量) 与常量字符串

再看这个代码：

int main()
{char* pstr = "hello";printf("pstr原来是%s\n", pstr);*(pstr + 2) = 'X';printf("pstr是%s", pstr);return 0;
}

运行结果：

可以看到，程序运行到“*(pstr + 2) = 'X';”就异常退出了。

我们调试起来看看：

可以发现，我们没有权限去修改这个字符串。

深层知识补充：（了解即可）

用数组保存字符串时，系统会开辟新的空间。
用指针保存字符串时，不会开辟新的空间，常量字符串是本来就存在的。对指针输入字符串时(如“char* str = "hello";”)，本质上是返回常量字符串的地址给指针。
常量字符串不可被修改的原因：常量字符串是存在于常量区的，进程看到的地址都是虚拟地址。虚拟地址空间经过页表的映射才能找到物理内存，而常量区经过页表映射的时候，权限就是只读的，所以不允许修改

6. 数组指针(变量)

6.1 数组指针的概念

根据前⾯学习的整型指针和字符指针，我们列出类⽐推理：

字符指针-->是指针变量-->存放的是字符变量的地址
整型指针-->是指针变量-->存放的是整型变量的地址
数组指针-->是指针变量-->存放的是数组的地址

思考一下，那我们应该怎样得到数组的地址？

~~使用&arr[0]？~~错：&arr[0]是数组首元素的地址
~~使用arr？~~错：arr仍然是首元素的地址
使用&arr，这才是代表数组的地址。

由此，我们来总结一下

数组指针的定义：

数组指针也是一种指针变量，全称是“指向数组的指针变量”。
数组指针(变量)存放的是数组的地址。

6.2 一维数组指针(变量)

（因为多维数组指针变量用不上，这里只讲一维数组指针变量）

(一)一维数组指针变量的初始化：

类型一维数组名[k]; //先要有一维数组
同类型 (*数组指针名)[同k] = &同一维数组名; //再有一维数组指针

(二)一维数组指针变量的数据类型：

去掉指针名后，中括号[ ]与小括号()的位置交换一下：
即“ 同类型[同k] (*) 或同类型[同k]* ”

注意：下标引用[ ]的优先级比解引用*的优先级高。如果不写括号，会变成(一级)指针数组，其本质就成数组了。

比如：

1. int arr[5] = {0,1,2,3,4};

2. int (*p)[5] = &arr;

一维数组指针p的数据类型是：int[5] (*)

拆分解析：

int (*p) [5] = &arr;

| | |

| | p所指向的数组arr 的总元素个数

| *p声明p是一个指针

p所指向的数组arr的单个元素的类型

不能不写或写错方括号中的数值，因为指针类型决定了指针+-整数的步长。

思考一下，&arr的数据类型是不是二级指针型？

调试举例：

可以发现，此处&arr的数据类型并不是二级指针型int**，而是数组指针型int[10]*

(arr[0]的类型是int，加上&后，&arr[0]的类型变成了int*；arr的类型是int[10]，加上&后，&arr的类型变成了int[10]*。【总结：加&添* 】)

6.3 行指针(变量)

行指针是一种特殊的数组指针，它与一维数组指针相似，但行指针并不是一维数组指针。

(一)行指针的初始化：

类型二维数组名[k1][k2];
同类型 (*数组指针名)[同k2] = 二维数组名;

(二)行指针的数据类型：

去掉指针名后，中括号[ ]与小括号()的位置交换一下：（这与一维数组指针类似）
即“ 同类型[同k2] (*) 或同类型[同k2]* ”

例如：

int arr[3][5] = { 0 };

int (*p)[5] = arr;

行指针p的数据类型是：int[3]*

拆分解析：

int (*p) [5] = &arr;

| | |

| | p所指向的数组arr中，一行的元素个数或列数（变了）

| *p声明p是一个指针（没变）

p所指向的数组arr的单个元素的类型（没变）

为什么行指针不是一维数组指针？

原因如下：（假设指针都称作p，一维数组叫arr1，二维数组叫arr2）

(1)一维数组指针的定义是：一维数组指针(变量)存放的是整个一维数组的地址，即p = &arr1。（指针的数据类型决定指针+-整数的步长，一维数组指针p的一个步长是整个一维数组arr1的长度）

(2)行指针的定义是：行指针(变量)存放的是二维数组的第一行的地址，即p = arr2。（指针的数据类型决定指针+-整数的步长，行指针p的一个步长就是二维数组arr2一行的长度）

7. 二维数组传参的本质

思考一下，二维数组形参的数据类型是二级指针？还是数组指针？

代码演示：

//打印二维数组的函数
void f(int arr[][3], int row, int col)
{for (int i = 0; i < row; i++){for (int j = 0; j < col; j++)printf("%d ", arr[i][j]);printf("\n");}
}
//mian函数
int main()
{int* a[4][3] = { {1},{2},{3} };f(a, 3, 3);return 0;
}