多维数组的地址，通过指针引用多维数组详解。
通过指针引用一维数组可以参考这篇文章：
C语言指针操作（三）通过指针引用数组
目录
一、多维数组的地址
1.1引入
1.2地址举例说明
1.3地址类型详解
1.4实例说明
二、指向多维数组元素的指针变量
2.1指向数组元素的指针变量
2.2指向由 m 个元素组成的一维数组的指针变量
三、用指向数组元素的指针作函数参数
3.1举例说明1
3.2举例说明2
指针变量可以指向一维数组中的元素，也可以指向多维数组中的元素；但在概念和使用方法上，多维数组的指针比一维数组的指针要复杂一些。
一、多维数组的地址
1.1引入
先定义一个二维数组
int a[3][4] = { {1,3,5,7},{9,11,13,15},{17,19,21,23} };a 是二维数组名，a 数组包含 3 行，即 3 个行元素：a[0]，a[1]，a[2]。而每一个行元素又是一个一维数组，它包含 4 个元素(即 4 个列元素)。例如， a[0] 所代表的一维数组又包含 4 个元素：a[0][0]，a[0][1]，a[0][2]，a[0][3]。可以认为二维数组是 “数组的数组”，即二维数组 a 是由 3 个一维数组所组成的。
从二维数组的角度来看，a 代表二维数组首元素的地址，现在的首元素不是一个简单的整型元素，而是由 4 个整型元素所组成的一维数组，因此 a 代表的是首行(即序号为 0 的行)的起始地址。a＋1代表序号为 1 的行的起始地址。如果二维数组的首行的起始地址为2000，一个整型数据占 4 个字节，则 a+1 的值应该是 2000+4×4=2016 (因为第 0 行有 4 个整型数据)。a+1 指向a[1]，或者说，a＋1 的值是 a[1] 的起始地址。a+2 代表 a[2] 的起始地址，它的值是2032。
a[0]，a[1]，a[2] 既然是一维数组名，从前面已知，数组名代表数组首元素地址，因此 a[0] 代表一维数组 a[0] 中第 0 列元素的地址，即 &a[0][0]。同理，a[1] 的值是 &a[1][0]，a[2] 的值是 &a[2][0]。
a[0] 是一维数组名，该一维数组中序号为 1 的元素的地址显然应该用 a[0]+1 来表示。此时 “a[0]+1” 中的 1 代表 1 个列元素的字节数，即4个字节。a[0] 的值是2000，a[0]+1 的值是2004(而不是2016)。这是因为现在是在一维数组范围内讨论问题，正如有一个一维数组x，x+1 是其第 1 个元素x[1] 的地址一样。a[0]+0，a[0]+1，a[0]+2，a[0]+3 分别是a[0][0]，a[0][1]，a[0][2]，a[0][3] 元素的地址(即 &a[0][0]，&a[0][1]，&a[0][2]，&[0][3])。
从上一篇文章可知，a[0] 和 *(a+0) 等价，a[1] 和 *(a+1) 等价，a[i] 和 *(a+i) 等价。
因此，a[0]+1和 *(a+0)+1 都是 &a[0][1](即地址都为2004)。a[1]+2 和 *(a+1)+2 的值都是 &a[1][2](即地址为2024)。请注意不要将*(a+1)+2 错写成 *(a+1+2)，后者变成 *(a+3) 了，相当于 a[3] 。进一步分析，欲得到 a[0][1] 的值，用地址法怎么表示呢？既然 a[0]+1 和 *(a+0)+1 是 a[0][1] 的地址，那么，*(a[o]+1) 就是 a[0][1] 的值。同理，*(*(a+0)+1) 或 *(*a+1) 也是 a[0][1] 的值。*(a[i]+j) 或 *(*(a+i)+j)是 a[i][j] 的值。务请记住 *(a+i) 和 a[i] 是等价的。
注意：a[i] 从形式上看是 a 数组中序号为 i 的元素。如果a是一维数组名，则 a[i] 代表 a 数组序号为 i 的元素的存储单元。a[i] 是一个有确定地址的存储单元。但如果 a 是二维数组，则 a[i] 是一维数组名，它只是一个地址，并不代表一个存储单元，也不代表存储单元中的值(如同一维数组名只是一个指针常量一样)。a，a+i，a[i]，* (a+i)，* (a+i)+j，a[i]+j 都是地址。而 *(a[i]+j) 和 *(*(a+i)+j) 是二维数组元素 a[i][j] 的值。
1.2地址举例说明
| 表现形式 | 含义 | 值 |
| a | 二维数组名，指向行，即一维数组a[0]，即0行的起始地址 | 2000 |
| a[0] | 一维数组名，指向列，即整型常量a[0][0]，即0行0列元素的地址 | 2000 |
| *(a+0)，*a | 0 行 0 列元素的地址 | 2000 |
| a+1，&a[1] | 第 1 行 (a[1]) 的起始地址 | 2016 |
| a[1]，*(a+1) | 第 1 行 0 列元素 a[1][0] 的地址 | 2016 |
| a[1]+2，*(a+1)+2，&a[1][2] | 第 1 行 2 列元素 a[1][2] 的地址 | 2024 |
| *(a[1]+2)，*(*(a+1)+2)，a[1][2] | 第 1 行 2 列元素 a[1][2] 的值 | 13 |
a+1 是二维数组 a 中序号为 1 的行的起始地址(序号从 0 起算)，而 *(a+1) 并不是 a+1 单元的内容(值)，因为 a+1 并不是一个数组元素的地址，也就谈不上存储单元的内容了。*(a+1) 就是 a[1]，而a[1] 是一维数组名，所以也是地址，它指向a[1][0]。a[1]和 *(a+1) 都是二维数组元素 a[1][0] 的地址的不同的表示形式。
1.3地址类型详解
C 语言的地址信息中既包含位置信息(如内存编号2000)，还包含它所指向的数据的类型信息。现在a[0] 是一维数组名，它是一维数组中起始元素的地址，a 是二维数组名，它是二维数组的首行起始地址，二者的纯地址是相同的；即2000，但它们的基类型不同，即它们指向的数据的类型不同，前者是整型数据，后者是一维数组。
如果用一个指针变量 pt 来指向一维数组，应当这样定义：
int (*pt)[4];int(*pt)[4]；表示 pt 指向由 4 个整型元素组成的一维数组，此时指针变量 pt 的基类型是由 4 个整型元素组成的一维数组。
a+1 与 a[0]+1 是不同的，a+1 是序号为 1 的行的起始地址，a+1 指向序号为 1 的行，而 *(a+1)或 a[1] 或 a[1]+0 都指向 1 行 0 列元素，二者地址虽相同，但指向的数据类型不同。a 和 a[0] 的值虽然相同(等于2000)，但是由于指针的基类型不同，a 指向一维数组a[0]，而 a[0] 指向列元素a[0][0]。因此，对不同的指针进行加 1 的运算，得到的结果是不同的。
注意：
二维数组名(如 a )是指向行(一维数组)的。因此 a+1 中的 “1” 代表一行中全部元素所占的字节数。一维数组名(如 a[0]，a[1] )是指向列元素的。a[0]+1 中的 1 代表一个 a 元素所占的字节数。在指向行的指针前面加一个 *，就转换为指向列的指针。例如，a 和 a+1 是指向行的指针，在它们前面加一个 * 就是 *a和 *(a+1)，它们就成为指向列的指针，分别指向 a 数组 0 行 0 列的元素和 1 行 0 列的元素。反之，在指向列的指针前面加 &，就成为指向行的指针。例如 a[0] 是指向 0 行 0 列元素的指针，在它前面加一个&，得 &a[0]，由于 a[0] 与 *(a+0)等价，因此 &a[0] 与 &*a 等价，也就是与 a 等价，它指向二维数组的 0 行。
注意：
不要把 &a[i] 简单地理解为 a[i] 元素的存储单元的地址，因为并不存在 a[i] 这样一个实际的数据存储单元。它只是一种地址的计算方法，能得到第 i 行的起始地址，&a[i] 和 a[i] 的值是一样的，但它们的基类型是不同的。&a[i] 或 a+i 指向行，而 a[i] 或 *(a+i) 指向列。当列下标 j 为 0 时，&a[i] 和 a[i] (即 a[i]+j )值相等，即它们的纯地址相同，但应注意它们所指向的对象的类型是不同的，即指针的基类型是不同的。*(a+i) 只是 a[i] 的另一种表示形式，不要简单地认为 *(a+i) 是 “ a+i 所指单元中的内容 ” 。在一维数组中 a+i 所指的是一个数组元素的存储单元，在该单元中有具体值。而对二维数组，a+i 不是指向具体存储单元而是指向行(即指向一维数组)。在二维数组中，a+i，a[i]，*(a+i)，&a[i]，&a[i][0] 的值相等，即它们都代表同一地址，但基类型不同。
1.4实例说明
#include<stdio.h>
int main()
{
int a[3][4] = { {1,3,5,7},{9,11,13,15},{17,19,21,23} };
printf("%p,%p\n", a, *a); //0行起始地址和0行0列元素的地址
printf("%p,%p\n", a[0], *(a + 0)); //0行0列元素的起始地址
printf("%p,%p\n", &a[0], &a[0][0]); //0行起始地址和0行0列元素的地址
printf("%p,%p\n", a[1], a + 1); //1行0列元素的地址和1行起始地址
printf("%p,%p\n", &a[1][0], *(a + 1) + 0); //1行0列元素的地址
printf("%p,%p\n", a[2], *(a + 2)); //2行0列元素的地址
printf("%p,%p\n", &a[2], a + 2); //2行起始地址
printf("%d,%d\n", a[1][0], *(*(a + 1) + 0));//1行0列元素的值
printf("%d,%d\n", *a[2], *(*(a + 2) + 0)); //2行0列元素的值
}
程序分析：
数组 a 的起始地址是 00EFFC74 (16进制) 。上面是在 VS2019 环境下的一次运行记录。在不同的计算机、不同的编译环境、不同的时间运行以上程序时，由于分配内存情况不同，所显示的地址可能是不同的。但是上面显示的地址是有共同规律的，如上面显示 0 行起始地址和 0 行 0 列元素地址为 00EFFC74，前 3 行显示的地址是相同的。第 4，5 行是 1 行 0 列元素地址和 1 行起始地址，它的值应当比上面显示的 0 行起始地址和 0 行 0 列元素地址大 16 个字节(一行有 4 个元素，每个元素 4 个字节)，00EFFC84 和 00EFFC74 之差是16。同样，第 6，7 行是 2 行 0 列元素地址和 ⒉行起始地址，它的值应当比 1 行起始地址和 1 行 0 列元素地址大 16 个字节，00EFFC94 和 00EFFC84 之差是16。最后两行显示的是 a[1][0] 和 a[2][0] 的值。
二、指向多维数组元素的指针变量
2.1指向数组元素的指针变量
实例：有一个3×4的二维数组，要求用指向元素的指针变量输出二维数组各元素的值。
#include<stdio.h>
int main()
{
int a[3][4] = { 1,3,5,7,9,11,13,15,17,19,21,23 };
int* p; //p是int* 型的指针
for (p = a[0]; p < a[0] + 12; p++) //使p依次指向下一个元素
{
if (p != a[0] && ((p - a[0]) % 4 == 0)) printf("\n"); //p移动4次后换行
printf("%4d ", *p); //输出p所指向元素的值
}
}运行结果：
程序分析：
p 是一个 int* 型(指向整型数据)的指针变量，它可以指向一般的整型变量，也可以指向整型的数组元素。每次使 p 值加 1，使 p 指向下一元素，比较简单。如果要输出某个指定的数值元素(例如 a[1][2] )，则应事先计算该元素在数组中的相对位置(即相对于数组起始位置的相对位移量)。计算 a[i][j] 在数组中的相对位置的计算公式为：i * m + j
其中，m 为二维数组的列数(二维数组大小为 n×m )。例如，对上述 3×4 的二维数组，它的 2 行 3 列元素 a[2][3] 对 a[0][0] 的相对位移量为 2×4+3=11 元素。如果一个元素占 4 个字节，则 a[2][3] 对 a[0][0]的地址差为 11×4=44 字节。若开始时指针变量 p 指向 a[0][0]，a[i][j] 的地址为 “&a[0][0]+(i*m+j)” 或 “p+(i*m+j)” 。a[2][3] 的地址是 (p+2*4+3)，即 (p+11)。a[2][3] 的值为 *(p+11)。
从图中可以看到在 a[i][j] 元素之前有 i 行元素(每行有 m 个元素)，在 a[i][j] 所在行，a[i][j] 的前面还有 j 个元素，因此 a[i][j] 之前共有 i×m+j 个元素。例如，a[2][3]的前面有两行，共 2×4=8 个元素，在它本行内还有 3 个元素在它前面，故共有 8+3=11 个元素在它之前，可用 p+11 表示其相对位置。
2.2指向由 m 个元素组成的一维数组的指针变量
上面实例的指针变量 p 是用 “int* p;” 定义的，它是指向整型数据的，p+1 所指向的元素是 p 所指向的列元素的下一元素(按在内存中存储的下一个整型元素)。可以改用另一方法，使 p 不是指向整型变量，而是指向一个包含 m 个元素的一维数组。这时，如果 p 先指向 a[0](即 p=&a[0] )，则 p+1 不是指向 a[0][1]，而是指向 a[1]，p 的增值以一维数组的长度为单位。
实例：输出二维数组任一行任一列元素的值
#include<stdio.h>
int main()
{
int a[3][4] = { 1,3,5,7,9,11,13,15,17,19,21,23 };
int(*p)[4] = a; //p是指向包含4个整型元素的一维数组的指针变量
int i, j;
printf("请输入要输出元素的行列号：");
scanf_s("%d,%d", &i, &j); //获得所需要的行列号
printf("a[%d,%d] = %d", i, j, *(*(p + i) + j)); //输出a[i][j]的值
}运行结果：
程序分析：
程序第 4 行中 “int(*p)[4];” 表示定义 p 为一个指针变量，它指向包含 4 个整型元素的一维数组。注意，*p 两侧的括号不可缺少，如果写成 *p[4]，由于方括号 [ ] 运算级别高，因此 p 先与 [4] 结合，p[4] 是定义数组的形式，然后再与前面的 * 结合，*p[4] 就是指针数组。
int(*p)[4]详解：
表示 (*p) 有 4 个元素，每个元素为整型。也就是 p 所指的对象是有 4 个整型元素的数组，即 p 是指向一维数组的指针。应该记住，此时 p 只能指向一个包含 4 个元素的一维数组，不能指向一维数组中的某一元素。p 的值是该一维数组的起始地址。虽然这个地址(指纯地址)与该一维数组首元素的地址相同，但它们的基类型是不同的。不要混淆。
实例：
#include<stdio.h>
int main()
{
int a[4] = { 1,3,5,7 };
int(*p)[4]; //p是指向包含4个整型元素的一维数组的指针变量
p = &a; //使p指向一维数组
printf("%d", (*p)[3]); //输出a[3]
}注意第 6 行不应写成 “p=a;” ，因为这样写表示 p 的值是 &a[0]，指向首元素a[0]。“p=&a;” 表示 p 指向一维数组(行)，(*p)[3] 是 p 所指向的行中列为 3 的元素。
注意：
要注意指针变量的类型,从 “int (*p)[4];” 可以看到，p 的类型不是 int* 型，而是 int(*)[4] 型，p 被定义为指向一维整型数组的指针变量，一维数组有 4 个元素，因此 p 的基类型是一维数组，其长度是16字节。
三、用指向数组元素的指针作函数参数
一维数组名可以作为函数参数，多维数组名也可作函数参数。用指针变量作形参，以接受实参数组名传递来的地址。可以有两种方法：
①用指向变量的指针变量
②用指向一维数组的指针变量
3.1举例说明1
实例：3 个学生，4 门课，计算总平均分数以及第 n 个学生的成绩
#include<stdio.h>
int main()
{
void average(float* p, int n); //average函数声明
void search(float(*p)[4], int n); //search函数声明
float score[3][4] = { {66,85,79,94},{88,98,76,84},{98,88,72,83} };
average(*score, 12); //求平均分
search(score, 2); //求序号为2的学生的成绩
return 0;
}
void average(float* p, int n)
{
float* q = p; //指针变量为int*型
float sum = 0, avg;
for (; q < p + n; q++)
sum += *q; //求和
avg = sum / n; //求平均值
printf("average = %5.2f\n", avg);
}
void search(float(*p)[4], int n)
{
printf("第%d位同学的成绩为：", n);
for (int i = 0; i < 4; i++)
printf("%5.2f ", *(*(p + n) + i)); //指针变量为int (*p)[4]
printf("\n");
}运行结果：
程序分析：
在 main 函数中，先调用 average 函数以求总平均值。在函数 average 中形参 p 被声明为 float* 类型(指向 float 型变量)的指针变量。它的基类型为 float 型，实参用 *score，即 score[0]，也就是&score[0][0]，即 score[0][0] 的地址。把 score[0][0] 的地址传给 p，使 p 指向score[0][0]。然后在average 函数中使 p 先后指向二维数组的各个元素，p 每加 1 就改为指向 score 数组的下一个元素。形参 n 代表需要求平均值的元素的个数，实参 12 表示要求 12 个元素值的平均值。
函数search的形参 p 的类型是 float(*)[4]，它不是指向整型变量的指针变量，而是指向包含 4 个元素的一维数组的指针变量。函数调用开始时，将实参 score 的值(代表该数组 0 行起始地址)传给p，使 p 也指向 score[0]。p+n 是 score[n] 的起始地址，*(p+n)+i 是score [n][i] 的地址，*(*(p+n)+i) 是 score[n][i] 的值。现在实参传给形参 n 的值是 2，即想找序号为 2 的学生的成绩。
调用 search 函数时，实参是 score(二维数组名，代表该数组中 0 行起始地址)传给 p，使 p 也指向score[0]。p+n 是 score[n] 的起始地址，*(p+n)+i 是 score[n][i] 的地址，*(*(p+n)+i) 是 score[n][i] 的值。现在 n=2，i 由 0 变到 3，for 循环输出 score[2][0] 到 score[2][3] 的值。
注意：
实参与形参如果是指针类型，应当注意它们的基类型必须一致。不应把 int* 型的指针(即数组元素的地址)传给 int(*)[4] 型(指向一维数组)的指针变量，反之亦然。
3.2举例说明2
在3.1实例的基础上，查找有一门以上课程不及格的学生，输出他们的全部成绩
#include<stdio.h>
int main()
{
void search(float(*p)[4], int n); //search函数声明
float score[3][4] = { {66,85,55,94},{88,98,43,84},{98,88,72,83} };
search(score, 3); //查找存在不及格同学的成绩
return 0;
}
void search(float(*p)[4], int n)
{
for (int i = 0; i < n; i++) //遍历每位同学
{
int flag = 0; //默认此同学不存在挂科情况
for (int j = 0; j < 4; j++)
if (*(*(p + i) + j) < 60)
{
flag = 1; //遍历一个同学的每科成绩，如果存在小于60分的，将flag标记为1
}
if (flag == 1) //如果flag==1，则此同学存在挂科，输出他的所有成绩
{
printf("第%d位同学存在挂科现象：", i + 1);
for (int j = 0; j < 4; j++)
printf("%5.2f ", *(*(p + i) + j));
printf("\n");
}
}
}运行结果：
程序分析：
实参 score 和形参 p 的类型是相同的。在调用 search 函数时，p 得到实参 score 的值，即 score[0] 的起始地址，也就是说 p 也指向 score 数组的第 1 行。然后 p 先后指向各行(每行包括该学生几门课的成绩)。p+i 是 score 数组第 i 行的起始地址，*(p+i) 是 score[i][0] 元素的地址，即 &score[i][0]，*(p+i)+j 是 score[i][j] 的地址，即 &score[i][j] ，search函数中的 *(*(p+i)+j)就是 score[i][j]。先后检查各学生每门课的成绩，如有不及格的就记录下来。
在函数 search 中，变量 flag 用来表示有无不及格的课程。若flag 的值为 1 表示有不及格的课程，若 flag 的值为 0 表示没有不及格的课程。开始时先使 flag=0，若发现某一学生有一门不及格，就使 flag 变为 1。最后用 if 语句检查 flag，如为 1，则表示该学生有不及格的记录，输出该学生全部课程成绩。变量 i 代表学生号，j 代表课程号。score[i][j] 是序号为 i 的学生第 i 门课的成绩。
通过指针变量存取数组元素速度快，程序简明。用指针变量作形参，所处理的数组大小可以改变。因此数组与指针常常是紧密联系的,使用熟练的话可以使程序质量提高，编写程序方便灵活。
C语言指针操作系列文章：
C语言指针操作（一）地址，指针，指针变量是什么
C语言指针操作（二）指针变量作为函数参数
C语言指针操作（三）通过指针引用数组
C语言指针操作（四）用数组名作函数参数
C语言指针操作（五）通过指针引用多维数组
C语言指针操作（六）通过指针引用字符串
C语言指针操作（七）指向函数的指针
C语言指针操作（八）返回指针值的函数
C语言指针操作（九）指针数组和多重指针
C语言指针操作（十）动态内存分配与指向它的指针变量文章来源：https://www.toymoban.com/news/detail-771617.html
C语言指针操作（十一）有关指针的小结文章来源地址https://www.toymoban.com/news/detail-771617.html
到了这里，关于C语言指针操作（五）通过指针引用多维数组的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
