08_数组

数组 (Arrays)

---

章节概述

数组是 C 语言中组织同类型数据的核心机制——连续排列的内存块，通过下标快速访问。本章从一维数组的声明与初始化出发，深入二维和高维数组的内存布局（行主序 row-major），讲解变长数组（VLA，C99 特性）、数组退化为指针的核心概念（array-to-pointer decay）、数组越界的危险（C 语言不进行边界检查！）、多维数组在栈和堆上的内存分配，最后通过 mermaid 图表和汇编代码展示数组寻址的底层机制（base + index * sizeof(element)）。理解数组在内存中的真实布局是理解指针、结构体、动态内存管理的基础。

核心主题：数组 = 连续内存块 + 首地址 + 偏移计算。CPU 通过 [base + offset * scale] 寻址模式实现数组访问——这也是为什么数组下标从 0 开始（偏移量 = 下标 × 元素大小）。C 语言不进行边界检查，意味着代码安全完全依赖程序员自律。

---

第一节：一维数组

---

1.1 声明、初始化、访问

#include <stdio.h>
 
int main() {
 // 声明（未初始化 → 内容不确定）
 int arr1[5];
 
 // 声明 + 初始化列表
 int arr2[5] = {10, 20, 30, 40, 50};
 
 // 部分初始化（剩余元素自动置 0）
 int arr3[5] = {1, 2}; // {1, 2, 0, 0, 0}
 
 // 自动推导长度
 int arr4[] = {1, 2, 3, 4, 5, 6}; // 长度为 6
 
 // 全零初始化
 int arr5[100] = {0};
 
 // C99 指定初始化器（designated initializer）
 int arr6[10] = {[2] = 5, [7] = 9};
 // arr6 = {0, 0, 5, 0, 0, 0, 0, 9, 0, 0}
 
 // 访问和修改
 arr2[0] = 100; // 修改第一个元素
 int x = arr2[3]; // 读取第四个元素
 
 // 遍历
 for (int i = 0; i < 5; i++) {
 printf("arr2[%d] = %d\n", i, arr2[i]);
 }
 
 return 0;
}

1.2 数组在内存中的布局

graph LR
 subgraph "int arr#91;5#93; = {10, 20, 30, 40, 50}"
 A0["arr#91;0#93;: 10<br/>地址 0x1000"] 
 A1["arr#91;1#93;: 20<br/>地址 0x1004"]
 A2["arr#91;2#93;: 30<br/>地址 0x1008"]
 A3["arr#91;3#93;: 40<br/>地址 0x100C"]
 A4["arr#91;4#93;: 50<br/>地址 0x1010"]
 end
 A0 --> A1 --> A2 --> A3 --> A4

内存地址（假设 arr 起始于 0x1000）：
0x1000: 0A 00 00 00 ← arr[0] = 10
0x1004: 14 00 00 00 ← arr[1] = 20
0x1008: 1E 00 00 00 ← arr[2] = 30
0x100C: 28 00 00 00 ← arr[3] = 40
0x1010: 32 00 00 00 ← arr[4] = 50

每个 int 占 4 字节 (sizeof(int) = 4)
地址递增步长 = sizeof(int) = 4

关键公式：

arr[i] 的地址 = arr (基地址) + i × sizeof(元素类型)

1.3 数组名 = 指向首元素的指针（但不能被赋值）

#include <stdio.h>
 
int main() {
 int arr[5] = {10, 20, 30, 40, 50};
 
 // arr 的类型是 int[5]（长度为 5 的 int 数组）
 // 但在大多数表达式中，arr 退化为 int*（指向首元素）
 
 printf("arr = %p\n", (void*)arr);
 printf("&arr[0] = %p\n", (void*)&arr[0]);
 // 两者地址相同！
 
 printf("*arr = %d\n", *arr); // 10 (arr[0])
 printf("*(arr+2) = %d\n", *(arr + 2)); // 30 (arr[2])
 
 // arr 可以参与指针运算但不可被赋值
 int *p = arr; // OK：指针 p 指向 arr 首元素
 // arr = p; // 编译错误！数组名不是可修改的左值
 
 // 字符串字面量是特殊情况
 char str[] = "hello"; // OK：在栈上分配数组并拷贝字符串
 // str = "world"; // 编译错误！数组名不可被赋值
 
 return 0;
}

1.4 指针算术与数组下标的关系

#include <stdio.h>
 
int main() {
 int arr[] = {10, 20, 30, 40, 50};
 
 // arr[i] 等价于 *(arr + i)
 // 实际上，C 标准定义了 E1[E2] 等价于 (*((E1)+(E2)))
 // 这意味着...
 
 printf("arr[2] = %d\n", arr[2]); // 30
 printf("*(arr+2) = %d\n", *(arr+2)); // 30
 
 // 甚至以下写法也是合法的（但不要这样写！）：
 printf("2[arr] = %d\n", 2[arr]); // 30！
 
 // 遍历数组的两种等价写法
 // 写法1：下标访问
 for (int i = 0; i < 5; i++) {
 printf("%d ", arr[i]);
 }
 printf("\n");
 
 // 写法2：指针遍历
 for (int *p = arr; p < arr + 5; p++) {
 printf("%d ", *p);
 }
 printf("\n");
 
 return 0;
}

小节练习

选择题 1

int arr[5] = {1, 2}; 之后，arr[3] 的值是？

• A. 未定义（垃圾值）

• B. 0

• C. 2

• D. 编译错误

点击查看答案 解析: C 语言规定，部分初始化列表中的剩余元素自动初始化为 0。arr = {1, 2, 0, 0, 0}。

正确答案: B

判断题 1

int arr[5]; arr = (int[]){1,2,3,4,5}; 可以给数组赋值。 （ ）

• 正确

• 错误

点击查看答案 解析: 数组名不是可修改的左值，不能放在赋值运算符左侧。这段代码是编译错误。复合字面量（C99）确实存在，但不能用于重新赋值数组名。正确做法是用 memcpy 或逐个元素赋值。

答案: 错误

---

第二节：多维数组

---

2.1 二维数组的声明和初始化

#include <stdio.h>
 
int main() {
 // 声明二维数组
 int matrix1[3][4]; // 3 行 4 列，未初始化
 
 // 完全初始化
 int matrix2[3][4] = {
 {1, 2, 3, 4}, // 第0行
 {5, 6, 7, 8}, // 第1行
 {9, 10, 11, 12} // 第2行
 };
 
 // 部分初始化
 int matrix3[3][4] = {
 {1, 2}, // 第0行: {1, 2, 0, 0}
 {5}, // 第1行: {5, 0, 0, 0}
 {} // 第2行: {0, 0, 0, 0}
 };
 
 // 平坦初始化（按行主序填充）
 int matrix4[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
 
 // 自动推导第一维长度
 int matrix5[][4] = {
 {1, 2, 3, 4},
 {5, 6, 7, 8},
 {9, 10, 11, 12}
 }; // 自动得出 3 行
 // 注意：第二维必须指定！编译器需要知道每行有多少列
 
 // 访问元素
 printf("matrix2[1][2] = %d\n", matrix2[1][2]); // 7
 
 return 0;
}

2.2 二维数组的内存布局（行主序 Row-Major）

graph TD
 subgraph "int matrix#91;3#93;#91;4#93; 内存布局"
 direction LR
 M0["0x1000<br/>matrix#91;0#93;#91;0#93; = 1"]
 M1["0x1004<br/>matrix#91;0#93;#91;1#93; = 2"]
 M2["0x1008<br/>matrix#91;0#93;#91;2#93; = 3"]
 M3["0x100C<br/>matrix#91;0#93;#91;3#93; = 4"]
 M4["0x1010<br/>matrix#91;1#93;#91;0#93; = 5"]
 M5["0x1014<br/>matrix#91;1#93;#91;1#93; = 6"]
 M6["0x1018<br/>matrix#91;1#93;#91;2#93; = 7"]
 M7["0x101C<br/>matrix#91;1#93;#91;3#93; = 8"]
 M8["0x1020<br/>matrix#91;2#93;#91;0#93; = 9"]
 M9["0x1024<br/>matrix#91;2#93;#91;1#93; = 10"]
 M10["0x1028<br/>matrix#91;2#93;#91;2#93; = 11"]
 M11["0x102C<br/>matrix#91;2#93;#91;3#93; = 12"]
 end
 M0 --> M1 --> M2 --> M3 --> M4 --> M5 --> M6 --> M7 --> M8 --> M9 --> M10 --> M11

C 语言采用行主序（Row-Major Order）：同一行的元素存储在连续的内存位置中。

matrix[i][j] 的地址 = matrix + (i × 列数 + j) × sizeof(element)
 = matrix + (i × 4 + j) × 4

#include <stdio.h>
 
int main() {
 int matrix[3][4] = {
 {1, 2, 3, 4},
 {5, 6, 7, 8},
 {9, 10, 11, 12}
 };
 
 // 证明二维数组在内存中是连续的一维数组
 int *p = (int*)matrix; // 或 &matrix[0][0]
 printf("平坦遍历: ");
 for (int i = 0; i < 12; i++) {
 printf("%d ", p[i]);
 }
 printf("\n"); // 1 2 3 4 5 6 7 8 9 10 11 12
 
 // 等价于
 printf("matrix[%d][%d] 的替代写法:\n", 1, 2);
 // matrix[i][j] = *(*(matrix + i) + j)
 printf("*(*(matrix+1)+2) = %d\n", *(*(matrix + 1) + 2));
 
 return 0;
}

2.3 三维数组和更高维

#include <stdio.h>
 
int main() {
 // 三维数组：层 × 行 × 列
 int cube[2][3][4] = {
 { // 第0层
 {1, 2, 3, 4}, // 第0层第0行
 {5, 6, 7, 8}, // 第0层第1行
 {9, 10, 11, 12} // 第0层第2行
 },
 { // 第1层
 {13, 14, 15, 16},
 {17, 18, 19, 20},
 {21, 22, 23, 24}
 }
 };
 
 printf("cube[1][2][3] = %d\n", cube[1][2][3]); // 24
 
 // 内存布局：仍然是行主序的延伸
 // cube[layer][row][col] 的偏移 =
 // layer × (rows × cols) + row × cols + col
 // = cube + (layer * 12 + row * 4 + col) * 4
 
 // 验证连续内存
 int count = 0;
 for (int l = 0; l < 2; l++)
 for (int r = 0; r < 3; r++)
 for (int c = 0; c < 4; c++)
 printf("%d ", cube[l][r][c] == ++count ? cube[l][r][c] : -1);
 printf("\n"); // 1..24 continuum
 
 return 0;
}

2.4 多维数组作为函数参数

#include <stdio.h>
 
// 传递二维数组 —— 必须指定所有维（除了第一维）
void print_matrix(int rows, int cols, int matrix[][4]) {
 for (int i = 0; i < rows; i++) {
 for (int j = 0; j < cols; j++) {
 printf("%3d ", matrix[i][j]);
 }
 printf("\n");
 }
}
 
// 等价的指针版本
void print_matrix_ptr(int rows, int cols, int *matrix) {
 for (int i = 0; i < rows; i++) {
 for (int j = 0; j < cols; j++) {
 // 手动计算偏移
 printf("%3d ", matrix[i * cols + j]);
 }
 printf("\n");
 }
}
 
int main() {
 int mat[3][4] = {
 {1, 2, 3, 4},
 {5, 6, 7, 8},
 {9, 10, 11, 12}
 };
 
 printf("二维数组版本:\n");
 print_matrix(3, 4, mat);
 
 printf("\n指针版本:\n");
 print_matrix_ptr(3, 4, &mat[0][0]);
 
 return 0;
}

小节练习

选择题 1

int arr[3][4] 在内存中占多少字节（64 位系统）？

• A. 12 字节

• B. 24 字节

• C. 48 字节

• D. 96 字节

点击查看答案 解析: 3 行 × 4 列 = 12 个 int 元素。每个 int 占 4 字节（64 位 Linux）。共 12 × 4 = 48 字节。数组内元素是连续存储的，没有行列之间的额外填充。

正确答案: C

选择题 2

二维数组传参时，下面哪个函数声明是正确的？

• A. void func(int arr[][])

• B. void func(int arr[3][])

• C. void func(int arr[][4])

• D. void func(int arr[3][4])

点击查看答案 解析: 传递二维数组时，除第一维外，所有其他维的大小必须指定。编译器需要知道每行多少个元素才能计算 arr[i][j] 的地址。C 省略第一维是可以的，D 全部指定也可以。

正确答案: C、D

---

第三节：变长数组（VLA — Variable Length Array）

---

3.1 VLA 的概念（C99 特性）

VLA（变长数组）允许在运行时确定数组的大小，数组长度可以是一个变量（非编译时常量）。

#include <stdio.h>
 
int main() {
 int n;
 printf("输入数组大小: ");
 scanf("%d", &n);
 
 // VLA：数组大小在运行时确定
 int arr[n]; // 在栈上分配 n 个 int
 
 // 初始化和使用
 for (int i = 0; i < n; i++) {
 arr[i] = i * 10;
 }
 
 for (int i = 0; i < n; i++) {
 printf("%d ", arr[i]);
 }
 printf("\n");
 
 // sizeof VLA：在运行时计算
 printf("sizeof(arr) = %zu 字节\n", sizeof(arr));
 // 运行时计算为 n * sizeof(int)
 
 return 0;
}

3.2 VLA 的限制和风险

#include <stdio.h>
 
int main() {
 int n;
 
 // 限制1：不能初始化（因为大小在编译时未知）
 // int arr[n] = {0}; // 编译错误！
 
 // 正确：声明后手动清空或逐个赋值
 n = 10;
 int arr[n];
 for (int i = 0; i < n; i++) arr[i] = i;
 
 // 限制2：不能作为全局数组（全局变量必须在编译时确定大小）
 
 // 风险1：栈溢出
 // 如果 n = 100000000，arr 占 ~400MB，远超栈大小 → 段错误
 // printf("输入 n: ");
 // scanf("%d", &n);
 // int huge[n]; // 可能是栈溢出！
 
 // 风险2：C11 将 VLA 变为可选特性
 // 部分编译器（如 MSVC）不支持 VLA
 
 // 风险3：VLA 作为函数参数的类型与指针相同
 void process(int rows, int cols, int mat[rows][cols]) {
 // 实际上 mat 仍然是指针
 for (int i = 0; i < rows; i++) {
 for (int j = 0; j < cols; j++) {
 mat[i][j] = i * cols + j;
 }
 }
 }
 
 int rows = 3, cols = 4;
 int matrix[3][4];
 process(rows, cols, matrix);
 
 return 0;
}

3.3 VLA vs 动态内存分配

特性	VLA	malloc/free
内存位置	栈（stack）	堆（heap）
生存期	函数内（出作用域自动释放）	手动管理（直到 free）
最大大小	受栈大小限制（~8MB）	受系统内存限制（GB 级）
性能	极快（仅移动栈指针）	较慢（需要堆管理）
可移植性	C99 可选	始终可用（C89 起）
可返回	否（函数返回后栈被回收）	是

#include <stdio.h>
#include <stdlib.h>
 
// VLA 版本 —— 数组在函数返回后即消失
void fill_vla(int n) {
 int arr[n];
 for (int i = 0; i < n; i++) arr[i] = i;
 // arr 在这里被销毁
}
 
// malloc 版本 —— 数组持续存在直到 free
int *fill_malloc(int n) {
 int *arr = (int*)malloc(n * sizeof(int));
 if (arr == NULL) return NULL;
 for (int i = 0; i < n; i++) arr[i] = i;
 return arr; // 安全返回，调用者负责 free
}
 
int main() {
 int *arr = fill_malloc(5);
 for (int i = 0; i < 5; i++) printf("%d ", arr[i]);
 printf("\n");
 free(arr); // 必须释放
 return 0;
}

关于动态内存管理（malloc/free）的详细讲解见 03_动态内存管理。

小节练习

判断题 1

VLA（变长数组）在 C11 标准中是强制性要求。 （ ）

• 正确

• 错误

点击查看答案 解析: C99 引入 VLA 作为强制特性，但 C11 将 VLA 降级为可选特性（编译器可以定义 __STDC_NO_VLA__ 表示不支持）。MSVC 就不支持 VLA。编写可移植代码时建议用 malloc 代替 VLA。

答案: 错误

---

第四节：数组越界与缓冲区溢出

---

4.1 C 语言不进行边界检查

#include <stdio.h>
 
int main() {
 int arr[5] = {1, 2, 3, 4, 5};
 
 // 越界写入 —— C 不报错！
 arr[5] = 999; // 写入了不属于 arr 的内存
 arr[10] = 888; // 可能覆盖其他变量或返回地址！
 
 // 越界读取 —— C 不报错！
 printf("arr[5] = %d\n", arr[5]); // 读取未知内存
 printf("arr[10] = %d\n", arr[10]); // 可能读取到其他变量的值
 
 // 后果：
 // 1. 未定义行为（UB）——可能崩溃，可能静默产生错误结果
 // 2. 覆盖邻近变量
 // 3. 覆盖返回地址（最危险！→ 安全漏洞的基础）
 
 int secret = 42;
 int buffer[4] = {0};
 // buffer[-1] 可能访问到 secret（取决于栈布局）
 printf("secret 附近的内存: buffer[-1] = %d\n", buffer[-1]);
 
 return 0;
}

4.2 缓冲区溢出是安全漏洞的根源

#include <stdio.h>
#include <string.h>
 
// 经典的安全漏洞示例（仅作教学用途）
void vulnerable(char *input) {
 char buffer[8]; // 只有 8 字节的缓冲区
 strcpy(buffer, input); // 如果 input 长于 8 字节 → 溢出！
 printf("buffer: %s\n", buffer);
 // 溢出的数据会覆盖栈上的其他内容（包括返回地址！）
}
 
int main() {
 // safe: "hello" 只有 6 字节（含 \0）
 vulnerable("hello");
 
 // 危险！这个输入如果被攻击者控制，可能覆盖返回地址
 // 导致任意代码执行（buffer overflow exploit）
 // vulnerable("AAAAAAAAAAAAAAAAAAAAAAAA");
 
 return 0;
}

graph TD
 subgraph "栈布局（正常的函数栈帧）"
 direction TB
 S1["低地址<br/>buffer#91;8#93;: 8 字节"]
 S2["saved rbp: 8 字节"]
 S3["返回地址: 8 字节"]
 S4["高地址<br/>调用者的栈帧"]
 end
 S1 --> S2 --> S3 --> S4
 
 subgraph "溢出后的栈布局"
 direction TB
 O1["低地址<br/>buffer#91;0#93;"]
 O2["AAAAAAAA ← 覆盖 buffer"]
 O3["AAAAAAAA ← 覆盖 saved rbp"]
 O4["攻击者地址 ← 覆盖 返回地址！"]
 O5["高地址"]
 end
 O1 --> O2 --> O3 --> O4 --> O5

缓冲区溢出是 C 语言最著名的安全问题，也是 Rust 语言设计的核心动力之一。安全编程实践见本教程第二部分；Rust 的内存安全方案见 。

小节练习

选择题 1

C 语言中访问数组越界时会发生什么？

• A. 编译错误

• B. 运行时异常（如 Java 的 ArrayIndexOutOfBoundsException）

• C. 未定义行为（UB）——结果不可预测

• D. 自动返回 0

点击查看答案 解析: C 语言为了性能不进行运行时边界检查。越界访问导致未定义行为：可能看似正常（读取到相邻变量），可能段错误，可能被攻击者利用。这是 C 语言最核心的安全风险。

正确答案: C

---

第五节：数组在汇编层的寻址

---

5.1 数组寻址的汇编指令

// C 代码
int sum_array(int arr[], int n) {
 int sum = 0;
 for (int i = 0; i < n; i++) {
 sum += arr[i];
 }
 return sum;
}

对应 x86-64 汇编（-O2 优化，简化版）：

sum_array:
 testl %esi, %esi ; 检查 n 是否 ≤ 0
 jle .L_ret_zero
 leal -1(%rsi), %eax ; eax = n - 1
 leaq 4(%rdi,%rax,4), %rdx ; 计算结束地址
 movl $0, %eax ; sum = 0
.L_loop:
 addl (%rdi), %eax ; sum += *rdi (arr[i])
 addq $4, %rdi ; rdi += 4 (指针前移一个 int)
 cmpq %rdx, %rdi ; 是否已到数组末尾？
 jne .L_loop
 ret
.L_ret_zero:
 xorl %eax, %eax
 ret

关键汇编寻址模式：

寻址模式	示例	含义	C 等效
基址+偏移	mov -8(%rbp), %eax	访问 rbp - 8 处的值	局部变量
基址+索引	mov (%rdi,%rax,4), %edx	访问 rdi + rax×4	arr[i]
基址+索引+偏移	mov 16(%rdi,%rax,8), %ecx	访问 rdi + rax×8 + 16	struct_arr[i].field

; arr[i] 的寻址：
; arr 在 rdi 中，i 在 rax 中
movl (%rdi, %rax, 4), %eax ; eax = arr[i]
; ^^^^
; 比例因子 = sizeof(int)
 
; 等价于: eax = *(arr + i * 4)
 
; arr[i][j] 的寻址（假设每行 4 列，即 col=4）：
; arr 在 rdi 中，i 在 rax 中，j 在 rcx 中
; 地址 = arr + (i * 4 + j) * 4 = arr + i * 16 + j * 4
leal (%rcx, %rax, 4), %edx ; edx = (i * 4 + j) ; 注意：这里 i*4 因为 col=4
movl (%rdi, %rdx, 4), %eax ; eax = arr[i][j]

数组寻址的本质是通过 Scale-Index-Base（SIB）字节编码实现的高效地址计算。详细汇编寻址模式见 。

5.2 数组在循环中的栈遍历

// C 代码
int main() {
 int arr[5] = {10, 20, 30, 40, 50};
 int sum = 0;
 for (int i = 0; i < 5; i++) {
 sum += arr[i];
 }
 return sum;
}

栈帧布局（-O0，简化）：

 ┌─────────────────────┐ 高地址
 │ 返回地址 │ rbp + 8
 ├─────────────────────┤
rbp → │ 旧的 rbp │
 ├─────────────────────┤
 │ arr[4] = 50 │ rbp - 4
 │ arr[3] = 40 │ rbp - 8
 │ arr[2] = 30 │ rbp - 12
 │ arr[1] = 20 │ rbp - 16
 │ arr[0] = 10 │ rbp - 20
 ├─────────────────────┤
 │ sum = 0 │ rbp - 24
 ├─────────────────────┤
 │ i = 0 │ rbp - 28
 ├─────────────────────┤
rsp → │ (低地址) │
 └─────────────────────┘

小节练习

选择题 1

在 x86-64 汇编中，movl (%rdi,%rax,4), %eax 这条指令的 C 语言等价代码是？

• A. eax = rdi + rax * 4;

• B. eax = *(int*)(rdi + rax * 4);

• C. eax = rdi[rax];

• D. eax = &rdi[rax];

点击查看答案 解析: (%rdi, %rax, 4) 是 x86 的 SIB 寻址：计算地址 rdi + rax × 4，然后将该地址处的值加载到 eax。比例因子 4 对应 sizeof(int)，等价于 arr[rax] 或 *(arr + rax)。

正确答案: B

---

章节测试

一、判断题（正确选，错误选）

判断题 1

int arr[10]; 声明中，arr 本身是一个可修改的指针变量。 （ ）

• 正确

• 错误

点击查看答案 解析: arr 是数组名，不是一个独立的指针变量。它不可修改（不能放在赋值左侧），但在表达式上下文会"退化"为指向首元素的指针。arr 没有独立的存储位置——它编译为数组首地址的常量。

答案: 错误

判断题 2

arr[i] 和 *(arr + i) 是完全等价的。 （ ）

• 正确

• 错误

点击查看答案 解析: C 标准明确规定：E1[E2] 等价于 (*((E1)+(E2)))。所以 arr[i] 和 *(arr+i) 在语义上完全相同。这也是 i[arr] 写法的理论基础（虽然不推荐使用）。

答案: 正确

判断题 3

C 语言运行时会自动检查数组越界。 （ ）

• 正确

• 错误

点击查看答案 解析: C 语言不进行任何运行时边界检查——这是为了性能（每个数组访问都做检查将显著降低性能）。程序员自己负责确保索引在合法范围内。

答案: 错误

判断题 4

二维数组 int arr[3][4] 在内存中按行主序（row-major）存储。 （ ）

• 正确

• 错误

点击查看答案 解析: C/C++ 语言规范要求二维数组按行主序存储：同一行的元素连续排列，第 i 行的最后一个元素与第 i+1 行的第一个元素相邻。这与 Fortran 的列主序相反。

答案: 正确

判断题 5

int arr[5] = {0}; 只把 arr[0] 初始化为 0，其他元素未初始化。 （ ）

• 正确

• 错误

点击查看答案 解析: 如果初始化列表的元素少于数组长度，剩余元素被自动初始化为 0。{0} 等价于 {0, 0, 0, 0, 0}。

答案: 错误

判断题 6

VLA（变长数组）可以用于声明全局变量。 （ ）

• 正确

• 错误

点击查看答案 解析: 全局变量和静态变量必须在链接时确定地址和大小，VLA 的大小在运行时才知道，因此只能用于局部变量（在栈上分配）。

答案: 错误

判断题 7

多维数组作为函数参数时，除第一维外，其他所有维度大小必须指定。 （ ）

• 正确

• 错误

点击查看答案 解析: 编译器需要知道每行有多少元素才能计算 arr[i][j] 的偏移。第一维在编译时不需要（因为计算偏移时第一维只影响 i×cols），其他维必须指定。

答案: 正确

判断题 8

sizeof(arr) 在函数内部能正确计算作为参数传递的数组的大小。 （ ）

• 正确

• 错误

点击查看答案 解析: 函数内的数组参数已退化为指针，sizeof(arr) 返回指针大小（通常 8 字节），而非原始数组大小。这是 C 语言最常见的陷阱之一。

答案: 错误

判断题 9

C 语言中 int w[10]; 后 sizeof(w) 返回 10 * sizeof(int)，即 40（假设 int=4）。 （ ）

• 正确

• 错误

点击查看答案 解析: 在声明数组的同一作用域内，sizeof(w) 仍能正确获取数组的总字节数（数组名还没有退化为指针）。用 sizeof(w) / sizeof(w[0]) 可以得到元素个数。

答案: 正确

判断题 10

数组在复制时（如 arr2 = arr1）会将所有元素复制到新数组。 （ ）

• 正确

• 错误

点击查看答案 解析: C 语言的数组不支持整体赋值。arr2 = arr1 是编译错误（数组名不可修改）。复制数组需要用 memcpy(arr2, arr1, sizeof(arr1)) 或循环逐个元素复制。

答案: 错误

---

二、选择题（单项选择题）

选择题 1

int arr[3][4] 中 arr[1][2] 的地址偏移是？

• A. arr + (1 + 2) * 4

• B. arr + (1 * 3 + 2) * 4

• C. arr + (1 * 4 + 2) * 4

• D. arr + (2 * 3 + 1) * 4

点击查看答案 解析: 行主序下，arr[1][2] 先跳过第 0 行（4 个元素），再到第 1 行的第 2 个元素。偏移 = (1 * 4 + 2) * sizeof(int) = 6 * 4 = 24。

正确答案: C

选择题 2

以下哪个声明合法？

• A. int arr[];（全局）

• B. int arr[0];（全局）

• C. int arr[] = {1,2,3};（全局）

• D. int arr[.5];

点击查看答案 解析: C 可以自动推导大小（int arr[] = {1,2,3} 等价于 int arr[3]）。A 错误（无推导信息的无大小数组），B 零长度数组非标准 C（GCC 扩展），D 语法错误。

正确答案: C

选择题 3

以下代码输出什么？

int arr[] = {10, 20, 30, 40};
int *p = arr;
printf("%d\n", *(p + 2));

• A. 10

• B. 20

• C. 30

• D. 40

点击查看答案 解析: p 指向 arr[0]，p + 2 指向 arr[2] → *(p+2) = 30。

正确答案: C

选择题 4

以下关于 VLA 的说法正确的是？

• A. VLA 在 C89 标准中就已存在

• B. VLA 的内存来自堆

• C. VLA 的大小可以在运行时确定

• D. VLA 可以用初始化列表 = {0}

点击查看答案 解析: VLA 是 C99 特性，大小在运行时确定，内存在栈上分配（不是堆），不能用初始化列表——因为大小编译时未知。

正确答案: C

选择题 5

数组越界写入最严重的后果是？

• A. 编译错误

• B. 运行时打印错误信息

• C. 覆盖返回地址导致任意代码执行

• D. 自动被操作系统阻止

点击查看答案 解析: 栈上的缓冲区溢出可以覆盖返回地址，攻击者可以通过精心构造的输入劫持程序控制流，执行任意代码。这是历史上最严重的软件安全漏洞类别（CWE-121）。

正确答案: C

选择题 6

int arr[3][4][5] 在内存中元素个数是？

• A. 12

• B. 20

• C. 35

• D. 60

点击查看答案 解析: 三维数组大小 = 3 × 4 × 5 = 60 个 int 元素。内存中所有 60 个元素连续排列。

正确答案: D

选择题 7

以下数组中哪个不能自动推导长度？

• A. int a[] = {1, 2, 3};

• B. int b[][3] = {{1,2,3}, {4,5,6}};

• C. int c[][3] = {};

• D. int d[3][] = {{1,2}, {3,4}};

点击查看答案 解析: 只有第一维可以省略。int d[3][] 省略了第二维而非第一维，是错误的——编译器无法推断每行有多少列。

正确答案: D

选择题 8

int arr[5]; printf("%zu", sizeof arr / sizeof arr[0]); 输出什么？

• A. 4

• B. 5

• C. 20

• D. 不确定

点击查看答案 解析: sizeof(arr) = 20（5 × 4 字节），sizeof(arr[0]) = 4（1 个 int），20 / 4 = 5——正确获取了元素个数。

正确答案: B

选择题 9

以下哪项是正确的三维数组 cube[2][3][4] 的内存偏移公式？

• A. cube + (l * 3 + r * 2 + c) * 4

• B. cube + (l * 12 + r * 4 + c) * 4

• C. cube + (l + r + c) * 4

• D. cube + (l * 3 * 4 + r * 4 + c) * 4

点击查看答案 解析: 三维数组偏移 = l × (3×4) + r × 4 + c = l×12 + r×4 + c 个元素。B 的 12 和 4 缺少了 ×4 的单位（元素数 vs 字节数）。更准确地说是元素偏移含 sizeof(int)。

正确答案: D

选择题 10

在 x86-64 汇编中访问 arr[i] 时，比例因子 scale 的值取决于什么？

• A. 数组的首地址

• B. 索引 i 的值

• C. 数组元素的 sizeof（元素类型大小）

• D. 数组长度

点击查看答案 解析: SIB 寻址中的 scale（比例因子）取决于 sizeof(元素类型)：1/2/4/8 对应 char/short/int/long。编译器在生成指令时根据数据类型选择正确的 scale。

正确答案: C

---

动手练习题

练习题 1：矩阵转置

难度: 简单

编写程序对 N×M 矩阵进行转置（行列互换）：

• 输入矩阵大小和元素
• 输出转置后的矩阵（M×N）
• 必须在原矩阵上”原地”转置（或使用额外数组）
• 观察转置前后内存中的元素排列变化

力扣练习：力扣矩阵操作题

练习题 2：二维数组的综合操作

难度: 简单

编写一个对学生成绩表的管理程序：

• 使用二维数组存储 5 个学生的 4 门课成绩
• 计算每个学生的总分和平均分
• 计算每门课的最高分、最低分、平均分
• 按总分排序（需要交换整行数据）

力扣练习：

• 力扣数组比较题
• 力扣多维数组操作题

练习题 3：杨辉三角

难度: 简单

用二维数组生成并打印杨辉三角的前 N 行：

• 使用 VLA 根据输入的 N 动态分配
• 或者使用固定大小 + 限制 N ≤ 最大大小
• 观察每一行的对称性
• 使用 %6d 格式化输出使其美观

力扣练习：力扣杨辉三角题

练习题 4：汇编层数组访问

难度: 简单

编写以下函数并用 gcc -S -O2 生成汇编：

1. int sum_arr(int *arr, int n) — 指针遍历累加
2. int sum_arr_idx(int arr[], int n) — 下标遍历累加
3. int sum_matrix(int rows, int cols, int mat[][4]) — 二维数组累加

比较汇编代码：

• 下标遍历和指针遍历的汇编是否相同？
• 观察二维数组的地址计算指令（lea + SIB）
• 验证 sizeof 被编译为立即数

参考 。

练习题 5：矩阵乘法

难度: 简单

力扣练习：力扣矩阵运算题

用 C 语言实现后，额外实验：

1. 实现三种循环顺序（i-j-k, i-k-j, j-i-k）的矩阵乘法
2. 用 clock() 计时，对 500×500 矩阵比较三种顺序的性能差异
3. 解释为什么循环顺序影响性能（缓存局部性 / cache locality）
4. 尝试使用 -O2 编译，观察编译器是否自动变换循环顺序