C 语 言 --- 数 组 2
💻作 者 简 介：曾 与 你 一 样 迷 茫，现 以 经 验 助 你 入 门 C 语 言
💡个 人 主 页：@笑口常开xpr 的 个 人 主 页
📚系 列 专 栏：C 启新程
✨代 码 趣 语：好 的 程 序 员 即 使 在 过 单 行 道 时 也 总 是 会 环 顾 两 边。
💪代 码 千 行，始 于 坚 持，每 日 敲 码，进 阶 编 程 之 路。
📦gitee 链 接：gitee
在 编 程 的 世 界 里，每 一 行 代 码 都 可 能 隐 藏 着 无 限 的 可 能 性 。你 是 否 想 过，一 个 小 小 的 程 序 究 竟 能 改 变 什 么？它 可 以 是 解 决 复 杂 问 题 的 工 具 ，也 可 以 是 实 现 梦 想 的 桥 梁。今 天，就 让 我 们 一 起 走 进 C 语 言 的 世 界，探 索 它 的 无 限 潜 力。
二 维 数 组
定义
和 一 维 数 组 类 似 ，二 维 数 组 本 质 上 可 以 理 解 为 “数 组 的 数 组”，形 象 地 说，它 就 像 一 个 表 格 或 者 数 学 中 的 矩 阵，由 行 和 列 组 成。在 二 维 数 组 中，每 个 元 素 都 需 要 通 过 两 个 索 引（ 行 索 引 和 列 索 引）来 精 准 定 位，这 与 仅 需 一 个 索 引 的 一 维 数 组 形 成 了 鲜 明 对 比。
语 法 格 式
数 据 类 型 数 组 名[常 量 表 达 式 1][常 量 表 达 式2];
常 量 表 达 式 1 表 示 数 组 的 行 数，常 量 表 达 式 2 表 示 数 组 的 列 数。
下 面 使 用 代 码 展 示
二 维 数 组 是 如 何 创 建 的。
#include<stdio.h>
int main()
{
int arr1[3][5];//3行5列
double data[5][8];
return 0;
}
初始化
按 行 初 始 化
可 以 使 用 嵌 套 的 花 括 号，按 行 对 二 维 数 组 进 行 初 始 化 ，每 一 对 花 括 号 表 示 一 行 元 素。
下 面 使 用 代 码 展 示
数 组 的 按 行 初 始 化。
#include<stdio.h>
int main()
{
int arr[3][4] = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} };
return 0;
}
在 上 面 的 代 码 中，定 义 了 一 个 二 维 整 型 数 组，名 称 为 arr，并 将 二 维 整 型 数 组 中 的 元 素 进 行 了 初 始 化。该 数 组 被 定 义 为 3 行 4 列，意 味 着 它 可 以 容 纳 12 个 整 型 数 据。这 里 采 用 的 是 完 全 初 始 化 的 方 式，即 对 数 组 的 所有 元 素 都 明 确 指 定 了 初 始 值，具 体 初 始 值 按 行 依 次 为 {1, 2, 3, 4}、{5, 6, 7, 8}、{9, 10, 11, 12}。
按 列 初 始 化
下 面 使 用 代 码 展 示
数 组 的 按 列 初 始 化。
#include<stdio.h>
int main()
{
int arr[3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
return 0;
}
在 上 面 的 代 码 中，定 义 了 一 个 二 维 整 型 数 组，名 称 为 arr。该 二 维 数 组 有 3 行 4 列，意 味 着 它 可 以 容 纳 12 个 整 型 数 据。这 里 采 用 的 是 按 列 依 次 赋 值 的 初 始 化 方 式，也 就 是 按 顺 序 把 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 这 些 值 赋 给 二 维 数 组 的 元 素。在 内 存 中，这 些 元 素 会 按 照 行 优 先 的 顺 序 存 储，即 先 存 储 第 一 行 的 4 个 元 素，再 存 储 第 二 行，最 后 存 储 第 三 行。
总 结
无 论 是 按 行 还 是 按 列 初 始 化 元 素 始 终 是 按 照 行 优 先 的 顺 序 存 储。
下 面 使 用 代 码 展 示
数 组 的 不 同 初 始 化。
#include <stdio.h>
int main()
{
int arr1[3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
int arr2[3][4] = { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} };
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
printf("%2d ", arr1[i][j]);
}
printf("\n");
}
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
printf("%2d ", arr2[i][j]);
}
printf("\n");
}
return 0;
}
部 分 初 始 化
下 面 使 用 代 码 展 示
部 分 初 始 化。
#include<stdio.h>
int main()
{
//未初始化的元素默认值为0
int arr[3][4] = { {1, 2}, {3, 4} };
return 0;
}
在 上 面 的 代 码 中，定 义 了 一 个 二 维 整 型 数 组，名 称 为 arr。该 数 组 的 大 小 为 3 行 4 列，意 味 着 它 可 以 容 纳 12 个 整 型 数 据。这 里 采 用 的 是 不 完 全 初 始 化 的 方 式，只 对 数 组 的 部 分 元 素 明 确 指 定 了 初 始 值。 具 体 来 说，第 一 行 仅 对 前 两 个 元 素 初 始 化 为 1 和 2，第 二 行 仅 对 前 两 个 元 素 初 始 化 为 3 和 4，而 对 于 其 余 未 显 式 初 始 化 的 元 素，会 自 动 将 其 默 认 初 始 化 为 0。
省 略 大 小
下 面 使 用 代 码 展 示
省 略 行 数 大 小。
#include<stdio.h>
int main()
{
int arr[][3] = { {1, 2, 3},{4, 5, 6},{7, 8, 9} };
int rows = sizeof(arr) / sizeof(arr[0]);
return 0;
}
sizeof(arr) 计 算 的 是 整 个 二 维 数 组 占 用 的 字 节 数，sizeof(arr[0]) 计 算的 是 数 组 一 行 占 用 的 字 节 数，两 者 相 除 得 到 数 组 的 行 数。
代 码 解 释
sizeof(arr) 计 算 的 是 整 个 二 维 数 组 arr 所 占 用 的 字 节 数。在 这 个 二 维 数 组 arr 中，它 有 3 行，每 行 有 3 个 int 类 型 的 元 素。在 常 见 的 32 位 或 64 位 系 统 中，int 类 型 通 常 占 用 4 个 字 节。因 此，整 个 二 维 数 组 总 共 包 含 3 * 3 = 9 个 int 类 型 的 元 素，那 么 sizeof(arr) 的 结 果 就 是 9 * 4 = 36 字 节。
sizeof(arr[0]) 计 算 的 是 数 组 中 第 一 行（ 即 arr[0] ）所 占 用 的 字 节 数。arr[0] 代 表 二 维 数 组 arr 的 第 一 行，它 是 一 个 包 含 3 个 int 类 型 元 素 的 一 维 数 组。所 以，sizeof(arr[0]) 的 结 果 是 3 * 4 = 12 字 节。
通 过 将 sizeof(arr) 除 以 sizeof(arr[0])，也 就 是 36 / 12，得 到 的 结 果 就 是 二 维 数 组 arr 的 行 数，即 3。
注 意 事 项：
列 数 不 能 省 略：因 为 编 译 器 需 要 根 据 列 数 来 划 分 初 始 化 列 表 中 的 元 素，从 而 确 定 每 行 的 元 素 个 数。如 果 省 略 列 数，编 译 器 将 无 法 正 确 解 析 初 始 化 列 表。
初 始 化 列 表 要 合 理：初 始 化 列 表 中 的 元 素 个 数 必 须 是 列 数 的 整 数 倍，否 则 会 导 致 编 译 错 误 或 未 定 义 行 为。
不 初 始 化
定 义 二 维 数 组 时，若 不 进 行 初 始 化，数 组 里 面 是 随 机 值。就 必 须 明 确 指 定 行 数 和 列 数；要 是 在 定 义 时 省 略 行 数，那 就 一 定 要 同 时 进 行 初 始 化，这 样 编 译 器 才 能 依 据 初 始 化 列 表 里 的 元 素 数 量 和 指 定 的 列 数 来 自 动 推 断 行 数。一 定 要 写 上 数 组 的 行 数 和 列 数 大 小，否 则 编 译 会 报 错。
下 面 使 用 代 码 展 示
不 对 二 维 数 组 进 行 初 始 化。
#include <stdio.h>
int main()
{
int arr[5][5];
return 0;
}
类 型
数 组 的 类 型 是：去 掉 数 组 名 剩 下 的 是 类 型。
下 面 使 用 代 码 展 示
数 组 的 类 型。
#include<stdio.h>
int main()
{
int data1[5][5];//int --- 数组元素的类型
//data1是数组名
//数组的类型是:去掉数组名剩下的是类型,int [5][5]
int data2[10][5];
//data2的类型是int [10][5]
return 0;
}
访 问 元 素
在 C 语 言 中，数 组 元 素 的 访 问 是 通 过 下 标 实 现 的，这 个 下 标 相 当 于 数 组 元 素 的 编 号。下 标 需 放 在 方 括 号 [ ] 中。下 标 是 从 0 开 始 计 数 的。若 一 个 数 组 包 含 n 个 元 素，那 么 其 首 个 元 素 的 下 标 为 0，最 后 一 个 元 素 的 下 标 则 是 n - 1。数 组 元 素 的 操 作 是 逐 个 元 素 去 处 理的 , 没 办 法 一 次 性 输 入,也 没 办 法 一 次 性 输 出 ,必 须 使 用 循 环。
[ ] — 下 标 引 用 操 作 符
方 法 一：
下 面 展 示
访 问 数 组 元 素。
#include <stdio.h>
int main()
{
int arr[3][5] = { 1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7 };//数组是3行5列
int i = 0;
int num = 1;
for (i = 0;i < 3;i++)
{
int j = 0;
for (j = 0;j < 5;j++)
{
arr[i][j] = num++;
}
}
for (i = 0;i < 3;i++)
{
int j = 0;
for (j = 0;j < 5;j++)
{
printf("%2d ", arr[i][j]);
}
printf("\n");
}
return 0;
}
方 法 二：
下 面 展 示
使 用 指 针 访 问 二 维 数 组 的 元 素。
#include <stdio.h>
int main()
{
int arr[3][5] = { 1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7 };//数组是3行5列
int i = 0;
int num = 1;
for (i = 0;i < 3;i++)
{
int j = 0;
for (j = 0;j < 5;j++)
{
arr[i][j] = num++;
}
}
int* p = &arr[0][0];
for (i = 0;i < 15;i++)
{
printf("%d ", *(p + i));
}
printf("\n");
return 0;
}
int* p = &arr[0][0];
定 义 一 个 整 型 指 针 p，并 将 其 指 向 二 维 数 组 arr 的 首 元 素 arr[0][0]。
printf("%d ", *(p + i));
p + i 表 示 指 针 p 向 后 偏 移 i 个 元 素 的 位 置。由 于 p 指 向 数 组 的 首 元 素，p + i 就 指 向 数 组 的 第 i 个 元 素。
*(p + i) 是 对 指 针 p + i 进 行 解 引 用 操 作，即 获 取 指 针 所 指 向 的 元 素 的 值。
二 维 数 组 在 内 存 中 的 存 储
下 面 展 示
代码示例。
#include<stdio.h>
int main()
{
int arr[3][5] = { 0 };
int i = 0;
for (i = 0;i < 3;i++)
{
int j = 0;
for (j = 0;j < 5;j++)
{
printf("arr[%d][%d] = %p\n", i, j, &arr[i][j]);
}
}
return 0;
}
%p 是 格 式 控 制 符，用 于 输 出 一 个 指 针 的 值，也 就 是 元 素 的 地 址。
&arr[i][j] 表 示 取 数 组 arr 中 第 i 行第 j 个 元 素 的 地 址。
通 过 观 察 输 出 的 地 址，我 们 不 难 发 现 二 维 数 组 元 素 在 内 存 中 是 连 续 存 储 的，相 邻 元 素 的 地 址 差 值 通 常 等 于 sizeof(int)。即 4 个 字 节。
总结
至 此，关 于 C 语 言 二 维 数 组 的 探 索 暂 告 一 段 落，但 你 的 编 程 征 程 才 刚 刚 启 航。写 代 码 是 与 机 器 深 度 对 话，过 程 中 虽 会 在 语 法、算 法 困 境 里 挣 扎，但 这 些 磨 砺 加 深 了 对 代 码 的 理 解。愿 你 合 上 电 脑 后，灵 感 不 断，在 C 语 言 的 世 界 里 持 续 深 耕，书 写 属 于 自 己 的 编 程 传 奇，下 一 次 开 启 ，定 有 全 新 的 精 彩 等 待。小 编 期 待 重 逢，盼 下 次 阅 读 见 你 们 更 大 进 步，共 赴 代 码 之 约！