C 语言核心数据结构：数组的内存模型与操作规范
1. 数组的本质与声明
在 C 语言体系中，数组被定义为具有相同数据类型且占用连续内存空间的变量集合。虽然标准允许使用变量定义长度（VLA），但这依赖于编译器对 C99 标准的兼容支持，且通常无法直接进行初始化。
#include <stdio.h>
int main() {
int limit;
printf("请输入数组长度：");
scanf("%d", &limit);
// 变长数组（VLA）声明，需注意兼容性且不支持初始化列表
int dataBuffer[limit];
return 0;
}2. 初始化的灵活性
数组的构建支持部分赋值或完全赋值。当提供的初始值少于数组容量时，剩余空间会自动补零。对于字符数组，字符串字面量初始化会自动包含末尾的空字符 `\0`。
#include <stdio.h>
int main() {
// 不完全初始化：未指定索引位置默认为 0
int nums[5] = {10, 20};
// 推断大小：根据初始值个数自动确定维度
int autoLen[] = {100, 200, 300};
// 字符数组差异对比
char strA[5] = {'x', 'y'}; // x y \0 \0 \0
char strB[5] = "xy"; // x y \0 \0 \0
char strC[] = "xy"; // x y \0 (大小为 3)
return 0;
}3. 单维数据的访问与遍历
通过下标运算符 `[]` 可以访问特定位置的元素。由于内存是连续的，我们可以通过计算总大小除以单个元素大小来获取实际长度，进而实现正向或逆向输出。
#include <stdio.h>
int main() {
int values[] = {5, 10, 15, 20, 25};
// 动态获取数组元素数量
long count = sizeof(values) / sizeof(values[0]);
printf("倒序输出：\n");
for (long idx = count - 1; idx >= 0; idx--) {
printf("%d ", values[idx]);
}
return 0;
}4. 内存连续性的验证
理解数组在物理内存中的布局至关重要。打印相邻元素的地址可以发现，它们之间的差值正好等于该元素的数据类型所占字节数（例如 int 通常为 4 字节），证明了线性存储的特性。
#include <stdio.h>
int main() {
int buffer[5] = {1, 2, 3, 4, 5};
long totalSize = sizeof(buffer) / sizeof(buffer[0]);
for (int k = 0; k < totalSize; k++) {
// %p 用于格式化指针地址
printf("Index %d address: %p\n", k, &buffer[k]);
}
return 0;
}5. 二维矩阵的构建规则
定义二维数组时，若使用初始化列表，第一维（行数）可以根据内容自动推导，但第二维（列数）必须显式指定。数据填充遵循"先行后列"的顺序，不足部分同样自动补零。
#include <stdio.h>
int main() {
// 明确指定行列
int grid1[2][3] = {{1, 2}, {3, 4}}; // 第三列自动为 0
// 省略行数
int grid2[][3] = {10, 20, 30, 40}; // 自动分为两行
// 等效于：{{10, 20, 30}, {40, 0, 0}}
return 0;
}6. 矩阵数据的迭代输出
处理二维结构通常需要嵌套循环。外层控制行索引，内层控制列索引，这样可以有序地遍历矩阵中的每一个数值。
#include <stdio.h>
int main() {
int matrix[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
for (int r = 0; r < 3; r++) {
for (int c = 0; c < 4; c++) {
printf("%d\t", matrix[r][c]);
}
printf("\n");
}
return 0;
}7. 二维内存布局分析
尽管二维数组在语法上看起来是分块的，但在底层它仍然是一块连续的内存区域。每一行的结束紧接着下一行的开始，不存在额外的开销。
#include <stdio.h>
int main() {
int table[2][3] = {0};
// 观察跨行时的地址变化
printf("&table[0][2]: %p\n", &table[0][2]);
printf("&table[1][0]: %p\n", &table[1][0]);
// 两者地址通常相差 sizeof(int)
return 0;
}8. 数组作为函数参数的陷阱
当数组传递给函数时，它会发生"退化"，变为指向首元素的指针。这意味着在函数内部使用 `sizeof(数组名)` 获取到的将是指针的大小而非整个数组的大小。建议使用选择排序等算法时务必传入长度参数。
#include <stdio.h>
// 选择排序：寻找未排序部分的最小值并交换
void selectionSort(int *ptr, int size) {
for (int i = 0; i < size - 1; i++) {
int minIdx = i;
for (int j = i + 1; j < size; j++) {
if (ptr[j] < ptr[minIdx]) {
minIdx = j;
}
}
if (minIdx != i) {
int tempVal = ptr[i];
ptr[i] = ptr[minIdx];
ptr[minIdx] = tempVal;
}
}
}
int main() {
int dataset[] = {5, 1, 9, 3, 7};
int len = sizeof(dataset) / sizeof(dataset[0]);
selectionSort(dataset, len);
for (int k = 0; k < len; k++) {
printf("%d ", dataset[k]);
}
return 0;
}9. 数组名字符语义的特殊性
通常情况下，数组名代表首元素地址。然而存在两个例外场景：一是配合 `sizeof` 运算符使用时，它代表整个数组对象；二是配合取地址符 `&` 使用时，它表示整个数组的地址。这两者与首元素地址在算术运算中表现出不同的步长。
#include <stdio.h>
int main() {
int myArr[5] = {0};
// 情况 1：常规情况下等同于首元素地址
printf("arr: %p\n", myArr);
printf("&myArr[0]: %p\n", &myArr[0]);
// 情况 2：取整体地址
printf("&myArr: %p\n", &myArr);
// myArr + 1 步进一个元素大小
printf("arr + 1: %p\n", myArr + 1);
// &myArr + 1 步进整个数组大小
printf("&myArr + 1: %p\n", &myArr + 1);
return 0;
}10. 多维数组名的寻址逻辑
对于二维数组，数组名表示的是第一行（也是一个一维数组）的首地址。通过组合 `sizeof` 运算符，我们可以分别计算出总行数、列数以及整个结构的字节占用。
#include <stdio.h>
int main() {
int table[3][4] = {0};
// 计算行数：总大小除以一行的大小
printf("Rows: %lu\n", sizeof(table) / sizeof(table[0]));
// 计算列数：一行的大小除以单个元素大小
printf("Cols: %lu\n", sizeof(table[0]) / sizeof(table[0][0]));
// 指针运算演示
printf("Start Row Addr: %p\n", table);
printf("Next Row Addr: %p\n", table + 1);
return 0;
}