【C语言入门】数组的深度解析

Mr_-G

墨衍会员 · AI 创作全网分发码龄6年

关注

原创最新推荐文章于 2026-10-18 10:19:48 发布 1.1k 阅读 AI 写同款· GEO 优化 ›

C语言中数组长度的计算方法总结（sizeof与strlen）本文章详细介绍了C语言常见的定义数组的方式，并且详细讨论了strlen与sizeof求解数组的原理和使用情况。适合C语言的初学者阅读。阅读详情

前言

数组是 C 语言中最基础的数据结构之一，也是理解内存管理、指针操作和复杂数据结构（如链表、树）的关键。本章节将从 “定义与特性”“内存布局”“操作与应用”“常见错误” 四个维度，结合代码示例和内存示意图，系统讲解数组的核心知识。

第一章数组的基础定义与核心特性

1.1 数组的标准定义

在 C 语言中，数组（Array）是一组连续存储的、相同数据类型的元素集合，其长度在定义时必须明确指定（静态数组）或通过变量动态确定（C99 变长数组）。

标准语法格式：

数据类型 数组名[数组长度];
// 示例：定义一个包含10个整数的数组
int ages[10];

1.2 特性一：固定长度 —— 为什么数组长度必须提前确定？

在 C 语言中，数组的 “固定长度” 特性源于其静态内存分配机制。当你定义一个数组时，编译器会直接在内存的 “栈区” 为其分配连续的存储空间，而栈区的内存大小在程序编译时就需要确定（因为栈的空间有限且需要提前规划）。

示例对比：
假设定义int arr[5];，编译器会在栈区分配5×4=20字节的连续空间（假设 int 占 4 字节）。如果允许运行时动态改变长度（比如从 5 变到 6），编译器无法提前规划内存，可能导致栈溢出（栈空间不足）或内存碎片。

1.3 特性二：同类型元素 —— 为什么不能混合类型？

数组的 “同类型” 特性由内存的地址计算方式决定。C 语言通过 “基地址 + 索引 × 元素大小” 来计算数组元素的内存地址。如果元素类型不同，每个元素的大小（如 int 占 4 字节，double 占 8 字节）会不一致，无法通过统一公式计算地址。

数学公式：
第 i 个元素的地址 = 数组起始地址 + i×sizeof (元素类型)
（示例：&arr[i] = &arr[0] + i×4，假设元素类型是 int）

1.4 例外：C99 变长数组（VLA）

C99 标准引入了 “变长数组（Variable-Length Array, VLA）”，允许使用变量作为数组长度（需注意：VLA 仍存储在栈区，长度在运行时确定但定义后不可修改）。

示例代码：

int n = 5;
int vla[n]; // 合法（C99标准）
n = 10;     // 可以修改变量n的值，但数组vla的长度仍为5！

第二章数组的内存布局与存储细节

2.1 一维数组的内存结构

一维数组在内存中是连续的线性存储，所有元素按索引顺序排列。

示例分析：
定义int arr[3] = {10, 20, 30};（假设 int 占 4 字节），内存布局如下：

内存地址（十六进制）存储内容（十进制）对应元素
0x1000 10 arr[0]
0x1004 20 arr[1]
0x1008 30 arr[2]

关键结论：
- 数组名（如arr）是数组首元素的地址（&arr[0]），但数组名本身不是指针变量（不能被重新赋值）。
- 元素地址的间隔等于元素类型的大小（如 int 间隔 4 字节，char 间隔 1 字节）。

内存地址（十六进制）	存储内容（十进制）	对应元素
0x1000	10	arr[0]
0x1004	20	arr[1]
0x1008	30	arr[2]

2.2 多维数组的内存本质

C 语言中没有真正的 “多维数组”，所谓的二维、三维数组本质上是 “数组的数组”。例如，二维数组int mat[2][3];可以理解为：

定义了一个包含 2 个元素的数组（mat[0]和mat[1]）；
每个元素本身又是一个包含 3 个 int 的数组。
内存布局：
int mat[2][3] = {{1,2,3}, {4,5,6}};的内存存储如下（连续存储）：

内存地址存储内容对应元素
0x2000 1 mat[0][0]
0x2004 2 mat[0][1]
0x2008 3 mat[0][2]
0x200C 4 mat[1][0]
0x2010 5 mat[1][1]
0x2014 6 mat[1][2]

关键结论：
- 二维数组在内存中仍是线性存储，行与行之间没有额外间隔；
- 二维数组的地址计算：&mat[i][j] = &mat[0][0] + (i×列数 + j)×元素大小。

内存地址	存储内容	对应元素
0x2000	1	mat[0][0]
0x2004	2	mat[0][1]
0x2008	3	mat[0][2]
0x200C	4	mat[1][0]
0x2010	5	mat[1][1]
0x2014	6	mat[1][2]

2.3 数组与指针的关系

数组名是 “常量指针”，指向数组首元素的地址，但数组名本身不是指针变量（不能被重新赋值）。

示例对比：
```
int arr[3] = {1,2,3};
int *p = arr; // p指向arr[0]的地址
arr = p;      // 错误！数组名是常量，不能被赋值
p = p + 1;    // 合法！指针p可以移动
```
关键区别：
- 数组名的地址（&arr）等于首元素地址（&arr[0]），但类型不同（&arr是 “数组指针”，类型为int(*)[3]；&arr[0]是 “int 指针”，类型为int*）。

第三章数组的操作与典型应用场景

3.1 数组的初始化与赋值

完全初始化：定义时为所有元素赋值

int arr[3] = {10, 20, 30}; // 3个元素分别为10、20、30

部分初始化：未赋值的元素自动初始化为 0（全局数组或静态数组）或随机值（局部数组）
```
int arr[5] = {1, 2}; // 元素为[1,2,0,0,0]（全局/静态数组）
```
省略长度初始化：数组长度由初始化列表的元素个数决定
```
int arr[] = {1,2,3}; // 等价于int arr[3] = {1,2,3};
```

3.2 数组的访问与遍历

索引访问：通过数组名[索引]访问元素（索引从 0 开始）

int arr[3] = {10,20,30};
printf("%d\n", arr[1]); // 输出20（第二个元素）

遍历方法：结合循环语句逐个访问元素

for (int i=0; i<3; i++) {
    printf("arr[%d] = %d\n", i, arr[i]);
}

3.3 数组作为函数参数

数组作为函数参数时，会退化为指针（传递的是数组首元素地址），因此函数无法直接知道数组的长度（需额外传递长度参数）。

示例代码：

// 函数声明：计算数组元素和（需传递数组和长度）
int sum(int *arr, int len) {
    int total = 0;
    for (int i=0; i<len; i++) {
        total += arr[i];
    }
    return total;
}

int main() {
    int arr[] = {1,2,3,4,5};
    int len = sizeof(arr)/sizeof(arr[0]); // 计算数组长度
    printf("Sum: %d\n", sum(arr, len)); // 输出15
    return 0;
}

关键结论：

数组作为参数传递时，本质是指针传递（时间复杂度 O (1)，无需复制整个数组）；
必须显式传递数组长度，否则函数无法确定数组边界（可能导致越界）。

3.4 典型应用场景

批量数据存储：如存储一个班级 50 名学生的成绩（int scores[50];）；
字符串处理：C 语言字符串本质是char数组（以\0结尾，如char str[] = "hello";）；
矩阵运算：二维数组用于存储矩阵（如int matrix[3][3];）；
缓冲区：如文件读取时的临时存储（char buffer[1024];）。

第四章数组的常见错误与调试技巧

4.1 数组越界访问

现象：访问索引小于 0 或大于等于数组长度的元素（如int arr[3]; arr[3] = 10;）。
后果：
- 栈溢出（覆盖其他变量内存）；
- 访问到 “脏数据”（未初始化的内存）；
- 程序崩溃（访问受保护内存）。

4.2 数组长度错误计算

错误示例：

void print_len(int arr[]) {
    int len = sizeof(arr)/sizeof(arr[0]); // 错误！arr退化为指针，sizeof(arr)是指针大小（8字节）
    printf("Length: %d\n", len); // 输出2（假设int占4字节，8/4=2）
}

正确方法：
数组长度必须在定义处计算（int len = sizeof(arr)/sizeof(arr[0]);），并作为参数传递给函数。

4.3 未初始化的局部数组

现象：局部数组（定义在函数内部的数组）未初始化时，元素值是内存中的 “残留数据”（随机值）。

示例验证：

int main() {
    int arr[3]; // 未初始化
    for (int i=0; i<3; i++) {
        printf("arr[%d] = %d\n", i, arr[i]); // 输出随机值（如-858993460）
    }
    return 0;
}

解决方案：显式初始化数组（如int arr[3] = {0};将所有元素初始化为 0）。

4.4 多维数组的错误初始化

错误示例：

int mat[2][3] = {{1,2}, {3,4,5}}; // 第一行只有2个元素，第二行有3个元素——合法但可能导致逻辑错误
int mat[2][3] = {1,2,3,4}; // 等价于{{1,2,3}, {4,0,0}}——未显式初始化的元素为0（全局/静态数组）

注意事项：
多维数组初始化时，外层大括号表示 “行”，内层大括号表示 “列”；未显式赋值的元素会根据数组类型自动填充（全局 / 静态数组填 0，局部数组填随机值）。

第五章扩展知识：数组与动态内存分配

虽然数组本身是固定长度的，但 C 语言提供了malloc、realloc等函数用于动态分配内存（堆区），可以模拟 “动态数组” 的效果。

示例：动态数组实现

#include <stdlib.h>

int main() {
    int n = 5;
    int *dyn_arr = (int*)malloc(n * sizeof(int)); // 动态分配5个int的空间
    if (dyn_arr == NULL) { // 检查内存分配是否成功
        exit(1);
    }

    // 使用动态数组（类似普通数组）
    for (int i=0; i<n; i++) {
        dyn_arr[i] = i+1;
    }

    // 调整数组长度（扩展为10个元素）
    int *new_arr = (int*)realloc(dyn_arr, 10 * sizeof(int));
    if (new_arr != NULL) {
        dyn_arr = new_arr; // 重新赋值指针
    }

    free(dyn_arr); // 释放内存（避免内存泄漏）
    return 0;
}

关键结论：