解码C语言数组

一维数组

数组是相同类型数据元素的有序集合，通过下标（索引）访问元素，内存中连续存储。

数组名表示首元素地址，sizeof(arr) 返回整个数组的字节大小

核心特点

• 元素类型一致：所有元素必须为同一数据类型（如 int, float）。
• 固定大小：数组长度在声明时确定，静态数组无法动态调整。
• 下标访问：下标从 0 开始，最大下标为 长度-1。

一维数组的定义与初始化

1. 基本语法

数据类型 数组名[长度];// 声明未初始化的数组
数据类型 数组名[长度] = {值列表};// 声明并初始化

• 示例：

  int numbers[5];// 声明长度为5的整型数组（元素值不确定）
  float scores[3] = {8.5, 9.0, 7.8};// 完全初始化
  char vowels[] = {'a', 'e', 'i', 'o', 'u'};// 自动推断长度为5
  

2. 初始化规则

• 未完全初始化：剩余元素自动填充零（数值类型）或空字符（字符类型）。

  int arr[5] = {1, 2};// [1, 2, 0, 0, 0]
  char str[10] = "Hi";// ['H','i','\0',0,...,0],\0是字符串数组的结束符(必须有)
  

• 静态初始化（全局数组）：未显式初始化时，默认全零。

  static int global_arr[3];// [0, 0, 0]
  

3.逐个赋值

声明数组后，通过循环或直接索引为每个元素赋值：

int arr[5];// 声明未初始化的数组
// 逐个赋值
arr[0] = 10;// 第一个元素
arr[1] = 20;
arr[2] = 30;
arr[3] = 40;
arr[4] = 50;// 或通过循环赋值
for (int i = 0; i < 5; i++) {arr[i] = (i + 1) * 10;// 赋值 10, 20, 30, 40, 50
}

4. 数组越界初始化

在C语言中，数组的初始化分为声明时初始化和动态初始化。越界问题在这两种情况下有不同的表现。

a) 声明时的初始化（使用初始化列表）

定义：指在声明数组的同时用大括号 {} 提供初始值列表时，提供的值的个数超过了数组声明的长度。

例子：

c

#include <stdio.h>int main() 
{
// 声明一个长度为5的数组，但尝试用6个值初始化它
int arr[5] = {1, 2, 3, 4, 5, 6};// 编译器会报错！return 0;
}

• 后果：这是一种编译时错误。编译器（如GCC）会直接报错，提示类似 excess elements in array initializer（初始化列表中的元素超出了数组的范围）。程序无法通过编译，无法生成可执行文件。
• 原因：数组的大小在编译时是固定的，编译器可以明确检查出初始值的数量是否匹配。

b) 动态初始化（运行时赋值）

定义：指在程序运行时，通过循环或其他逻辑为数组元素赋值时，循环变量或索引计算错误，导致试图对数组范围之外的内存进行赋值。

例子：

c

#include <stdio.h>int main() {int arr[5];int i;// 错误：循环了6次 (i从0到5)，最后一次arr[5]是越界写入for(i = 0; i <= 5; i++) {// 应该是 i < 5arr[i] = i * 10;}return 0;
}

• 后果：这是一种运行时错误，属于未定义行为。编译器通常不会报错（最多可能给出警告），但程序运行时的行为是不可预测的。它可能会覆盖其他重要的数据（如其他变量、函数调用的返回地址），导致程序崩溃或产生诡异的结果。

二、数组元素的操作

1. 访问元素

通过下标（索引）访问，范围从 0 到 长度-1：

int data[4] = {10, 20, 30, 40};
printf("%d\n", data[0]);// 输出10
data[3] = 50;// 修改最后一个元素为50

2. 遍历数组

使用 for 循环遍历所有元素：

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

• 关键技巧：用 sizeof(data)/sizeof(data[0]) 计算数组长度。

字符数组 与 字符串 的对比

对比项	字符数组	字符串
本质	存储字符序列的一维数组，元素类型为 char。	以 '\0' 结尾的字符数组（本质是字符数组的特殊形式）。
终止符	可无 '\0'（若仅作字符集合使用）。	必须 以 '\0' 结尾，否则字符串操作函数可能出错。
初始化方式	char arr1[] = {'H','i'};（无终止符，长度2）char arr2[] = "Hi";（自动添加 '\0'，长度3）	必须包含 '\0'：char str[] = "Hello";（隐式添加 '\0'）
内存占用	长度由显式定义或初始化列表决定。	长度 = 字符数 + 1（多1字节存放 '\0'）。
操作函数	需手动遍历处理字符。	可用标准库函数（如 strlen, strcpy, strcat）。
常见用途	原始字节缓冲区、非文本数据存储。	文本处理、文件读写、用户输入输出。
长度计算	sizeof(arr) 返回数组总字节数。	strlen(str) 返回 '\0' 前的字符数（不含终止符）。
修改权限	可自由修改内容（非 const 时）。	字符串字面量（如 "Hello"）存储在常量区，不可修改。
输入输出	需逐个处理字符或自定义格式。	可直接用 %s 格式化输入输出。

4. 数组访问越界

这是C语言中最常见且最危险的错误之一。

定义：指在使用数组时，下标索引的值不在 [0, 数组长度 - 1] 这个有效范围内。包括读越界和写越界。

例子：

c

#include <stdio.h>
int main() 
{int arr[5] = {10, 20, 30, 40, 50};// 有效索引: 0, 1, 2, 3, 4// 1. 读越界 - 读取不存在的数据printf("越界读取: %d\n", arr[5]);// 索引5无效printf("越界读取: %d\n", arr[-1]);// 索引-1无效// 2. 写越界 - 向非法内存地址写入数据（极其危险！）arr[5] = 100;// 破坏未知的内存arr[100] = 200;// 更严重的破坏return 0;
}

二维数组

二维数组的定义与初始化

1. 基本语法

数据类型 数组名[行数][列数];// 声明未初始化的二维数组
数据类型 数组名[行数][列数] = {初始化值};// 声明并初始化

• 示例：

  int matrix[3][4];// 声明3行4列的整型数组（元素值不确定）
  float grid[2][3] = {{1.1, 2.2, 3.3}, {4.4, 5.5, 6.6}};// 完全初始化
  char chessboard[][3] = {{'X', 'O'}, {'O', 'X'}};// 自动推断行数为2(列数表示元素类型列数不能不声明)
  

2. 初始化规则

• 逐行初始化：内层花括号对应行，可省略内部括号（按顺序填充）。

  int arr[2][3] = {1, 2, 3, 4, 5, 6};// 等效于 {{1,2,3}, {4,5,6}}
  

• 部分初始化：未初始化的元素自动填充零。

  int arr[2][3] = {{1}, {4, 5}};// 第一行 [1,0,0]，第二行 [4,5,0]
  

二、二维数组的内存布局

1. 存储方式

二维数组在内存中按 行优先顺序 连续存储：

int arr[2][3] = {{1,2,3}, {4,5,6}};

内存布局（假设 int 占4字节）：

地址: 0x1000 → 1 (arr[0][0])
地址: 0x1004 → 2 (arr[0][1])
地址: 0x1008 → 3 (arr[0][2])
地址: 0x100C → 4 (arr[1][0])
地址: 0x1010 → 5 (arr[1][1])
地址: 0x1014 → 6 (arr[1][2])

2. 计算元素地址

对于 arr[row][col]，其内存地址为：

基地址 + (row * 列数 + col) * sizeof(数据类型)

三、二维数组的常见操作

1. 遍历数组

嵌套循环访问所有元素：

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

变长数组

核心特性：一旦创建，其大小就固定了，不能再改变。 这里的“变长”指的是“长度由变量决定”，而不是“长度可以变化”。

基本语法和示例

#include <stdio.h>int main() 
{int size;printf("请输入数组的大小: ");scanf("%d", &size);// 运行时才确定大小// 声明一个变长数组 (Variable-Length Array, VLA)// 其长度由变量size的值决定int myArray[size];// 像普通数组一样使用for (int i = 0; i < size; i++) {myArray[i] = i * 2;}for (int i = 0; i < size; i++) {printf("myArray[%d] = %d\n", i, myArray[i]);}return 0;
}

主要特点

1. 长度由变量决定：数组的长度可以是任何整数表达式（只要结果为正数），而不仅仅是常量。

   int n = 10;
   int m = 5;
   float arr1[n];// 合法
   float arr2[n*2 + 1];// 合法
   float arr3[m*n];// 合法
   

2. 通常分配在栈上：与普通自动（局部）数组一样，VLA通常在函数调用栈上分配内存。这是其最大的限制之一。

3. 作用域和生命周期：VLA是自动存储期的对象。它的生命周期仅限于其所在的作用域（例如，函数内部或块内部）。当程序离开声明它的块时，数组占用的内存会自动被释放。

4. 不允许在文件作用域或静态存储期使用：

   // int global_vla[n]; // 错误！VLA不能是全局的
   // static int static_vla[n]; // 错误！VLA不能是static的
   int main() 
   {// 只能在块作用域内使用int n = 5;int vla[n];// 正确
   }
   

5. 不能初始化：声明VLA时不能同时进行初始化。

   int n = 5;
   int vla[n] = {1, 2, 3, 4, 5};// 错误！编译不通过
   

零长数组

零长数组是一种在结构体中声明的、长度为零的数组。它的主要用途是作为结构体的最后一个成员，指向一段动态分配的内存空间，从而使整个结构体能够容纳可变长度的数据。

基本形式：

struct my_struct 
{int some_data;char flexible_data[0];// 这就是零长数组
};

在C语言中，结构体的大小通常是固定的。但有时我们需要一个结构体来存储一个可变长度的数据（例如，一个可变长度的字符串、一个动态数量的数组等）。

不优雅的解决方案（过去）：

在零长数组出现之前，程序员常用一种称为“struct hack”的技巧，即声明一个长度为1的数组。

struct my_struct 
{int length;char data[1];// 长度为1的数组
};

然后动态分配内存时，分配 sizeof(struct my_struct) + (actual_length - 1) 的大小。这种方法可行，但语法上不美观，且标准未明确支持。

零长数组的解决方案：

零长数组让这个“Hack”变得更加直观和自然。它明确表示：“这个数组没有占用结构体本身的空间，它只是另一个内存区域的起点”。

使用零长数组的标准步骤是：

1. 定义结构体：将零长数组作为最后一个成员。
2. 动态分配内存：为结构体本身 加上 你希望零长数组拥有的实际长度分配内存。
3. 使用数据：像使用普通数组一样使用零长数组成员。

示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 定义包含零长数组的结构体
struct line 
{int length;char contents[0];// 零长数组
};int main() 
{int desired_length = 20;
// 动态分配内存：结构体基础大小 + 所需的数组大小struct line *thisline = (struct line *)malloc(sizeof(struct line) + desired_length * sizeof(char));thisline->length = desired_length;
// 现在可以使用 contents 数组了，它拥有 20 个字符的空间strncpy(thisline->contents, "Hello, World!", desired_length);printf("Content: %s\n", thisline->contents);printf("Length: %d\n", thisline->length);// 释放内存free(thisline);return 0;
}

数组与数组名

1. 数组名（Array Name）

数组名是一个标识符，它代表整个数组。但在大多数表达式中，它会自动转换为指向其首元素的指针。

int arr[5] = {10, 20, 30, 40, 50};

arr 的含义：

• 类型：int* （指向整型的指针）
• 值：&arr[0] （数组第一个元素的地址）
• 指针运算：以单个元素为单位进行偏移

示例：

printf("arr:     %p\n", (void*)arr);// 输出数组首元素地址
printf("&arr[0]: %p\n", (void*)&arr[0]);// 输出数组首元素地址
// 两者输出相同printf("*arr: %d\n", *arr);// 输出 10 (解引用得到第一个元素)
printf("*(arr + 1): %d\n", *(arr + 1));// 输出 20 (向后移动一个int的大小)

2. &数组名（Address of Array Name）

&arr 获取的是整个数组的地址。

&arr 的含义：

• 类型：int (*)[5] （指向长度为5的整型数组的指针）
• 值：与 arr 相同（因为数组的地址就是其首元素的地址）
• 指针运算：以整个数组为单位进行偏移

示例：

printf("&arr:    %p\n", (void*)&arr);// 输出整个数组的地址// 这个值与 arr 相同，但类型不同// 指针运算的差异：
printf("arr + 1: %p\n", (void*)(arr + 1));// 地址增加 4 字节（一个int的大小）
printf("&arr + 1: %p\n", (void*)(&arr + 1));// 地址增加 20 字节（5个int的大小，即整个数组的大小）

3. 对比表格

特性	arr (数组名)	&arr (数组的地址)
类型	int*	int (*)[5]
指向对象	第一个元素 arr[0]	整个数组 arr
值（地址）	与 &arr[0] 相同	与 arr 相同
+1 的偏移量	sizeof(int) 字节	sizeof(int[5]) 字节（即20字节）
主要用途	访问数组元素	操作整个数组（如传递给函数）