C语言二维数组详解(基础入门):从 Excel 表格到内存长龙
- 2026-11-17 02:12:14
现在,学完一维数组你可能觉得「数组嘛,就是一串连续的数据,搞定」。但现实世界里有太多数据天然就是表格状的——成绩单、棋盘、像素图片……这时候一维数组就不够用了。这篇文章我们专攻基础:二维数组是什么、怎么创建、怎么使用,以及它在内存里的真实样子。
一、先想一个问题:为什么需要二维数组?
假设你是老师,班上有 3 个学生,每个学生考了 4 门课。成绩长这样:
语文 数学 英语 体育张三 85 92 78 88李四 79 85 90 82王五 92 88 85 91
如果用一维数组存,你只能这样:
int scores[12] = {85,92,78,88, 79,85,90,82, 92,88,85,91};问题是——拿到第 7 个数(90),它到底是哪个学生的哪门课?你得自己在脑子里算:「第 7 个 → 第二个人 → 第三门 → 李四的英语」。这不仅麻烦,代码操作也极其别扭。
二维数组就是来解决这个问题的。 它让你用「第几行、第几列」的方式直接定位数据,就像查 Excel 表格一样自然。
// 3个学生(行) × 4门课(列)int scores[3][4] = {{85, 92, 78, 88}, // 张三{79, 85, 90, 82}, // 李四{92, 88, 85, 91} // 王五};// scores[1][2] → 第1行第2列 → 李四的英语 → 90
好,现在你知道「为什么」了,我们正式开始。
二、二维数组到底是什么?
2.1 官方定义
二维数组:相同数据类型元素按「行」和「列」排列成的矩形集合。
- 相同数据类型
— 一个二维数组里所有元素类型一样(全是 int,或全是 double,不能混) - 行和列
— 横的叫行(row),竖的叫列(column) - 矩形
— 每行的列数一样多,不存在第一行 3 列、第二行 5 列的不规则形状
2.2 用图来理解
假设 int arr[2][3],逻辑结构:
列[0] 列[1] 列[2]行[0] arr[0][0] arr[0][1] arr[0][2]行[1] arr[1][0] arr[1][1] arr[1][2]
一共 2 行 × 3 列 = 6 个元素。每个元素用 数组名[行号][列号] 唯一确定。
2.3 换个角度:二维数组 = 「以一维数组为元素的数组」
这是一个非常重要的认知,慢慢说。
先回想一维数组:
int a[3] = {10, 20, 30};a 是一个数组,里面有 3 个 int 类型的元素。
现在,把 int 这个类型换成「长度为 3 的一维 int 数组」:
int arr[2][3];理解为:arr 是一个数组,里面有 2 个元素,每个元素本身又是一个长度为 3 的一维 int 数组。
arr[0] → [ ][ ][ ] ← 这是一个 int[3] 类型的一维数组arr[1] → [ ][ ][ ] ← 这又是一个 int[3] 类型的一维数组
🧠 这个理解方式非常重要,后面学「数组指针」「动态二维数组」时你会反复用到。现在只需记住:二维数组的每一行,本质上就是一个独立的一维数组。
2.4 行号和列号都从 0 开始
C 语言所有数组下标从 0 开始:
行号范围: 0到行数 - 1列号范围: 0到列数 - 1
int arr[2][3] 中:行号只能用 0、1;列号只能用 0、1、2。
三、怎么定义一个二维数组?
3.1 基本语法
数据类型 数组名[行数][列数];数据类型 | intdouble、char | |
数组名 | arrmatrix、scores | |
[行数] | 23+2 | |
[列数] | 35 |
3.2 举个最简例子
int arr[2][3];这行代码做了什么?
向内存申请 2 × 3 = 6个int大小(共6 × 4 = 24字节)的连续空间给这块空间起名叫 arr用「2 行 3 列」的逻辑视图组织这 6 个 int
但是——此时数组里都是「垃圾值」(未初始化,里面是内存残留的随机数据),跟普通变量一样,定义 ≠ 赋值。
3.3 行数和列数为什么必须是常量?
int n = 3;int arr[2][n]; // ❌ 传统C语言不允许(除非用C99变长数组,下篇讲)
编译器在编译阶段就要知道数组占多少内存。变量的值要到运行时才知道,编译时没法确定。
四、初始化——给二维数组赋初值的四种写法
这是实际写代码最频繁的操作,每种都要搞明白。
4.1 写法一:完全初始化(线性填充)
int arr[2][3] = {1, 2, 3, 4, 5, 6};填充规则:从第 0 行第 0 列开始,从左到右、一行填满自动换到下一行,依次填入。
过程追踪:
填第1个值 1 → arr[0][0] = 1填第2个值 2 → arr[0][1] = 2填第3个值 3 → arr[0][2] = 3 ← 第0行填满,自动换行填第4个值 4 → arr[1][0] = 4填第5个值 5 → arr[1][1] = 5填第6个值 6 → arr[1][2] = 6最终:arr[0][0]=1 arr[0][1]=2 arr[0][2]=3arr[1][0]=4 arr[1][1]=5 arr[1][2]=6
💡 这种写法数据多了很难一眼看出哪个值属于哪一行。
4.2 写法二:分组初始化(大括号嵌套)⭐ 推荐
int arr[2][3] = {{1, 2, 3}, // 第0行{4, 5, 6} // 第1行};
每对大括号 { } 代表一行,行和列一目了然,日常开发强烈推荐。
某一行没给全的情况:
int arr[2][3] = {{1, 2}, // 只给了2个值{4} // 只给了1个值};
规则:没给到的元素,编译器自动填 0。
结果:arr[0][0]=1 arr[0][1]=2 arr[0][2]=0 ← 缺的自动补0arr[1][0]=4 arr[1][1]=0 arr[1][2]=0 ← 缺的自动补0
⚡ 记忆口诀:有就填,没有就补 0。
4.3 写法三:不完全初始化
int arr[2][3] = {1, 2, 3, 4}; // 只给了4个值结果:
arr[0][0]=1 arr[0][1]=2 arr[0][2]=3arr[1][0]=4 arr[1][1]=0 arr[1][2]=0 ← 自动补0
C 语言规定:只要初始化列表给了至少一个值,所有未被显式赋值的元素,统统自动置为 0。
一键清零——最极端的用法:
int arr[2][3] = {0};把整个二维数组所有元素都设为 0。原理:{0} 先把 arr[0][0] 设为 0,其余元素因为「未显式赋值」自动补 0。
⚠️
{0}只能做到全 0,不能把数组初始化成其他统一值。{1}的结果是只有arr[0][0] = 1,其余全是 0。
4.4 写法四:省略行号
int arr[][3] = {1, 2, 3, 4, 5, 6};行号可以不写,编译器自己推算:6 个元素 ÷ 3 列 = 2 行。
int arr[][3] = {1, 2, 3, 4, 5, 6, 7}; // 7÷3=2余1 → 3行但列号绝对不能省! 不告诉编译器每行几列,它怎么知道 {1,2,3,4,5,6} 该排成 2×3 还是 3×2 还是 1×6?
int arr[][] = {1,2,3,4,5,6}; // ❌ 编译报错!int arr[2][] = {1,2,3,4,5,6}; // ❌ 编译报错!
📌 黄金法则:可以省略行,绝对不能省略列。
4.5 四种初始化总结
int a[2][3] = {1,2,3,4,5,6}; | ||
int a[2][3] = {{1,2,3},{4,5,6}}; | 日常开发首选 | |
int a[2][3] = {1,2}; | ||
int a[][3] = {1,2,3,4,5,6}; |
🔴 碎碎念:初始化常见坑
int a[2][3] = {1,2,3,4,5,6,7}; | |||
int a[2][] = {1,2,3}; | int a[][3] | ||
{1} 是全 1 | int a[2][3] = {1}; | a[0][0]=1,其余全是 0 | |
int a[2][3]; printf("%d",a[0][0]); |
五、怎么访问二维数组里的元素?
5.1 用下标精确定位
访问格式:数组名[行号][列号],把它想成坐标系:
列0 列1 列2行0 [ 1 ] [ 2 ] [ 3 ]行1 [ 4 ] [ 5 ] [ 6 ]
想取 3?第 0 行、第 2 列 → arr[0][2]想取 4?第 1 行、第 0 列 → arr[1][0]想取 6?第 1 行、第 2 列 → arr[1][2]
5.2 打印单个元素
#include<stdio.h>intmain(){int arr[2][3] = {1, 2, 3, 4, 5, 6};printf("%d\n", arr[0][2]); // 输出:3printf("%d\n", arr[1][0]); // 输出:4printf("%d\n", arr[1][2]); // 输出:6return 0;}
arr[行号][列号] 等价于一个普通 int 变量——可以打印、赋值、参与运算:
arr[0][1] = 99; // 赋值int sum = arr[0][0] + arr[1][1]; // 参与运算
🔴 碎碎念:下标易错
int arr[2][3]) | ||
|---|---|---|
arr[2][0] | ||
arr[0][3] | ||
arr[0,2] | arr[2] |
六、遍历——用双重循环访问所有元素
6.1 为什么需要两层循环?
二维数组有两维(行 + 列),一层循环只能搞定一维。必须嵌套:
- 外层循环 → 控制「当前在处理第几行」
- 内层循环 → 控制「当前行里的第几列」
6.2 完整代码,逐行讲解
#include<stdio.h>intmain(){int arr[2][3] = {1, 2, 3, 4, 5, 6};int row = 2; // 总行数int col = 3; // 总列数for (int i = 0; i < row; i++) // ① 外层:第 i 行{for (int j = 0; j < col; j++) // ② 内层:该行第 j 列{printf("%d ", arr[i][j]); // ③ 打印当前元素 + 空格}printf("\n"); // ④ 该行结束,换行}return 0;}
逐行解释:
① for (int i = 0; i < row; i++):i从 0 走到 1(共 2 行),每轮处理一行② for (int j = 0; j < col; j++):j从 0 走到 2(每行 3 列)③ printf("%d ", arr[i][j]):打印当前元素,%d后面的空格让元素分开④ printf("\n"):注意它在内层循环外面——一行所有列打完再换行
6.3 执行过程逐步追踪
i=0 时(处理第 0 行):j=0 → 打印 arr[0][0] = 1j=1 → 打印 arr[0][1] = 2j=2 → 打印 arr[0][2] = 3内层循环结束 → 换行i=1 时(处理第 1 行):j=0 → 打印 arr[1][0] = 4j=1 → 打印 arr[1][1] = 5j=2 → 打印 arr[1][2] = 6内层循环结束 → 换行i=2 → 不满足 i < row → 外层循环结束
输出:
1 2 34 5 6
💡 C 语言圈子里习惯
i代表行、j代表列。另外行优先遍历(外层行,内层列)效率最高,因为内存就是按行存储的。
七、从键盘输入数据到二维数组
7.1 先回顾 scanf
int x;scanf("%d", &x); // 从键盘读一个整数,存入变量 x
"%d":告诉程序「我在等一个整数」 &x:取地址,告诉程序「存到 x 所在的内存位置」
7.2 给二维数组输入数据
#include<stdio.h>intmain(){int arr[2][3]; // 先定义,不初始化int row = 2, col = 3;// 输入阶段for (int i = 0; i < row; i++)for (int j = 0; j < col; j++)scanf("%d", &arr[i][j]); // 逐个读取// 输出验证for (int i = 0; i < row; i++){for (int j = 0; j < col; j++)printf("%d ", arr[i][j]);printf("\n");}return 0;}
输入过程追踪(假设你输入 10 20 30 40 50 60):
i=0, j=0: scanf 读到 10 → arr[0][0] = 10i=0, j=1: scanf 读到 20 → arr[0][1] = 20i=0, j=2: scanf 读到 30 → arr[0][2] = 30i=1, j=0: scanf 读到 40 → arr[1][0] = 40i=1, j=1: scanf 读到 50 → arr[1][1] = 50i=1, j=2: scanf 读到 60 → arr[1][2] = 60
输出:
10 20 3040 50 60
💡
scanf会跳过空格和换行,所以用空格分隔(10 20 30)或每行换行输入都可以。
🔴 碎碎念:输入易错点
& | scanf("%d", arr[i][j]); | scanf("%d", &arr[i][j]); | |
scanf("%f", &arr[i][j]); | scanf("%d", &arr[i][j]); | %d,double 用 %lf | |
八、二维数组在内存中的真面目 ⭐⭐⭐
这是全篇最重要的部分,搞懂了它,后面指针、动态内存都不虚。
8.1 先做实验:打印每个元素的地址
#include<stdio.h>intmain(){int arr[2][3] = {0};for (int i = 0; i < 2; i++)for (int j = 0; j < 3; j++)printf("&arr[%d][%d] = %p\n", i, j, &arr[i][j]);return 0;}
&arr[i][j]:取 arr[i][j] 这个元素的地址 %p:专门打印地址的占位符 你运行出的地址值跟我不一样,但地址之间的差值一定相同
输出示例:
&arr[0][0] = 0x6D7AFC08&arr[0][1] = 0x6D7AFC0C ← 比上一个地址大 4&arr[0][2] = 0x6D7AFC10 ← 比上一个地址大 4&arr[1][0] = 0x6D7AFC14 ← 比 arr[0][2] 大 4(跨行也是连续的!)&arr[1][1] = 0x6D7AFC18 ← 比上一个地址大 4&arr[1][2] = 0x6D7AFC1C ← 比上一个地址大 4
8.2 分析地址差
int 类型占 4 字节。看上面:
0x6D7AFC08 → 0x6D7AFC0C 差 0x0C - 0x08 = 40x6D7AFC0C → 0x6D7AFC10 差 0x10 - 0x0C = 40x6D7AFC10 → 0x6D7AFC14 差 0x14 - 0x10 = 4...
相邻元素严格差 4 字节,没有跳跃、没有空隙。
8.3 关键结论:行优先(Row-Major)连续存储
arr[0][2](第 0 行最后一个)的地址是 0x6D7AFC10,紧接着 arr[1][0](第 1 行第一个)是 0x6D7AFC14,差 4。
第 0 行和第 1 行在内存里是紧密衔接的——这就是「行优先存储」:先完整存储第 0 行的所有列,紧接着存第 1 行,再接着存第 2 行……
8.4 逻辑视图 vs 物理视图
你脑子里看到的(逻辑视图) 实际内存里存放的(物理视图)┌───────────────────────┐ ┌───┬───┬───┬───┬───┬───┐│ arr[0]: [1] [2] [3] │ │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 ││ arr[1]: [4] [5] [6] │ = └───┴───┴───┴───┴───┴───┘└───────────────────────┘ 地址递增 →
🧠 核心认知:二维是给你看的,一维才是它本来的样子。二维数组在内存里就是一条长龙,只不过你用「行列」标记给它划分了段落。
8.5 万能地址公式
arr[i][j] 的地址 = 数组首地址 + (i × 总列数 + j) × sizeof(元素类型)验证:arr[1][2] 在 int arr[2][3] 中的位置:
偏移 = (1 × 3 + 2) × 4 = (3 + 2) × 4 = 5 × 4 = 20 字节arr[1][2] 的地址 = arr[0][0]的地址 + 20= 0x6D7AFC08 + 14(十六进制)= 0x6D7AFC1C ✅ 跟实验输出一模一样!
理解这个公式有什么用?
以后学指针操作二维数组,本质就在用这个公式 动态分配二维数组时,要手动算偏移 考试/面试常考题:「给定首地址,求 arr[i][j]的地址」
🔴 碎碎念:内存相关误区
char 差 1,double 差 8 |
本篇(上篇)总结
| 概念 | |
| 定义 | 类型 数组名[行数][列数] |
| 初始化 | |
| 访问 | 数组名[行号][列号] |
| 遍历 | |
| 输入 | scanf("%d", &arr[i][j])& |
| 内存 | 行优先(Row-Major)连续存储(i × col + j) × sizeof(type) |
本篇到这里,你已经搞懂了二维数组的「是什么」和「怎么基本操作」。下篇我们会进入进阶内容:C99 变长数组、矩阵转置实战、以及 4 道经典面试题,把二维数组的火候真正练到家!