C 语言数组详解:从声明、初始化到指针与多维数组
1. 引言
数组是 C 语言中最基础也最重要的数据结构之一。它把相同类型的元素连续地存放在一段内存中,让我们可以用一个名字加下标来访问一组数据。理解数组,是理解指针、字符串、函数传参乃至内存布局的前提。
本文从数组的声明与初始化讲起,逐步深入到数组与指针的关系、多维数组、常见陷阱,最后给出几个可运行的完整示例。
2. 什么是数组
数组是一组类型相同、内存连续的变量的集合。它的几个关键特征:
- 类型一致:所有元素必须是同一类型,如
int、char、double。 - 内存连续:元素在内存中依次排列,第
i个元素的地址等于首地址加上i * sizeof(元素类型)。 - 长度固定:C 语言数组在定义时确定长度,运行期间不能改变(变长数组 VLA 除外,见后文)。
- 下标从 0 开始:长度为
n的数组,合法下标是0到n-1。
int scores[5]; // 5 个 int 元素,下标 0~4
3. 数组的声明与初始化
3.1 声明
int a[10]; // 10 个 int
double b[4]; // 4 个 double
char c[32]; // 32 个 char,常用于字符串缓冲区
3.2 初始化
int a[5] = {1, 2, 3, 4, 5}; // 完全初始化
int b[5] = {1, 2}; // 部分初始化,其余元素自动为 0
int c[5] = {0}; // 全部置 0 的常用写法
int d[] = {1, 2, 3}; // 省略长度,编译器自动推导为 3
需要注意:
- 局部数组未初始化时,元素是不确定值(垃圾值),不要直接读取。
- 全局数组和
static数组未显式初始化时,元素自动为 0。 - 指定初始化器(C99)可以按位置赋值:
int e[5] = {[0] = 1, [3] = 4}; // e = {1, 0, 0, 4, 0}
4. 数组元素的访问与遍历
数组通过 数组名[下标] 访问元素。下标可以是整型表达式,编译器不会检查越界,越界访问属于未定义行为。
#include <stdio.h>
int main(void) {
int a[5] = {10, 20, 30, 40, 50};
for (int i = 0; i < 5; i++) {
printf("a[%d] = %d\n", i, a[i]);
}
a[2] = 300; // 修改元素
printf("a[2] = %d\n", a[2]);
return 0;
}
遍历时推荐用 sizeof 计算元素个数,避免硬编码长度:
size_t n = sizeof(a) / sizeof(a[0]);
for (size_t i = 0; i < n; i++) {
/* ... */
}
注意:
sizeof(a) / sizeof(a[0])只在数组本身可见时有效。数组作为函数参数传入后会退化为指针,此时sizeof得到的是指针大小。
5. 数组与指针的关系
这是 C 语言数组最容易混淆的部分,务必理清。
5.1 数组名退化为指针
在大多数表达式中,数组名会被转换为指向首元素的指针:
int a[5] = {1, 2, 3, 4, 5};
int *p = a; // 等价于 &a[0]
因此下面几种写法完全等价:
a[i] // 下标访问
*(a + i) // 指针偏移后解引用
*(p + i)
p[i]
5.2 数组名不是指针
数组名在 sizeof 和取地址 & 两种场景下不会退化:
int a[5];
printf("%zu\n", sizeof(a)); // 20(5 * sizeof(int)),不是指针大小
printf("%p\n", (void *)&a); // 整个数组的地址,类型是 int (*)[5]
5.3 数组作为函数参数
数组作为参数时会退化为指针,函数内部无法得知数组长度,必须额外传入长度:
void print_array(const int *arr, size_t n) {
for (size_t i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}
/* 调用 */
int a[5] = {1, 2, 3, 4, 5};
print_array(a, 5);
void f(int arr[]) 与 void f(int *arr) 在函数参数中完全等价。
6. 多维数组
6.1 二维数组的声明与初始化
int m[3][4]; // 3 行 4 列
int n[2][3] = {{1, 2, 3}, {4, 5, 6}};
int k[2][3] = {1, 2, 3, 4, 5, 6}; // 按行展开,等价于上一行
int z[2][3] = {0}; // 全部置 0
6.2 内存布局
C 语言的多维数组本质是数组的数组,按行优先连续存储。int m[3][4] 在内存中依次是 m[0][0]、m[0][1]……m[2][3]。
#include <stdio.h>
int main(void) {
int m[3][4] = {
{1, 2, 3, 4},
{5, 6, 7, 8},
{9, 10, 11, 12}
};
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 4; j++) {
printf("%3d ", m[i][j]);
}
printf("\n");
}
return 0;
}
6.3 二维数组作为函数参数
二维数组传参时,必须指定除第一维以外的所有维度,因为编译器需要知道每行有多少元素才能正确计算偏移:
void print_matrix(int m[][4], int rows) {
for (int i = 0; i < rows; i++) {
for (int j = 0; j < 4; j++) {
printf("%3d ", m[i][j]);
}
printf("\n");
}
}
7. 字符数组与字符串
C 语言没有独立的字符串类型,字符串就是以 '\0' 结尾的字符数组。
char s1[] = "hello"; // 长度 6,含结尾 '\0'
char s2[6] = {'h','e','l','l','o','\0'}; // 与上一行等价
char s3[10] = "hi"; // 剩余元素自动为 0
常见操作:
#include <stdio.h>
#include <string.h>
int main(void) {
char buf[32] = "hello";
printf("长度: %zu\n", strlen(buf)); // 5,不含 '\0'
strcat(buf, " world"); // 拼接,注意缓冲区足够大
printf("%s\n", buf); // hello world
return 0;
}
使用
strcpy、strcat、sprintf等函数时务必确认目标缓冲区足够大,否则会造成缓冲区溢出。更安全的做法是使用strncpy、snprintf等带长度限制的版本。
8. 常见陷阱与注意事项
- 数组越界:C 不做边界检查,
a[5]访问长度为 5 的数组属于未定义行为,可能崩溃也可能悄悄改坏其他变量。 - 数组不能整体赋值:
int b[5]; b = a;是非法写法,需要用memcpy或循环逐个复制。 - 数组不能作为函数返回值:函数不能返回局部数组,应返回指针(指向静态/堆内存)或由调用方传入缓冲区。
sizeof陷阱:数组传参后退化为指针,sizeof(arr)得到的是指针大小而非数组大小。- 字符串忘记
'\0':手动构造字符数组时若漏掉结尾'\0',printf("%s")会越界读取。 - 变长数组(VLA):C99 支持
int n = 10; int a[n];,但长度在运行时确定,且不能初始化,栈空间有限时慎用。
9. 综合示例:数组排序与查找
下面给出一个完整可运行的示例,演示数组的遍历、排序与查找:
#include <stdio.h>
/* 冒泡排序 */
void bubble_sort(int *a, int n) {
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - 1 - i; j++) {
if (a[j] > a[j + 1]) {
int t = a[j];
a[j] = a[j + 1];
a[j + 1] = t;
}
}
}
}
/* 二分查找,返回下标,找不到返回 -1 */
int binary_search(const int *a, int n, int key) {
int lo = 0, hi = n - 1;
while (lo <= hi) {
int mid = lo + (hi - lo) / 2;
if (a[mid] == key) return mid;
if (a[mid] < key) lo = mid + 1;
else hi = mid - 1;
}
return -1;
}
int main(void) {
int a[] = {42, 7, 19, 3, 88, 56, 21};
int n = sizeof(a) / sizeof(a[0]);
bubble_sort(a, n);
printf("排序后: ");
for (int i = 0; i < n; i++) {
printf("%d ", a[i]);
}
printf("\n");
int key = 19;
int idx = binary_search(a, n, key);
if (idx >= 0) {
printf("找到 %d,下标为 %d\n", key, idx);
} else {
printf("未找到 %d\n", key);
}
return 0;
}
输出:
排序后: 3 7 19 21 42 56 88
找到 19,下标为 2
10. 小结
| 主题 | 关键要点 |
|---|---|
| 声明与初始化 | 长度固定,部分初始化补 0,{0} 可全部置零 |
| 访问 | 下标从 0 开始,编译器不检查越界 |
| 与指针 | 数组名多数场景退化为首元素指针,sizeof/& 例外 |
| 函数传参 | 退化为指针,必须额外传长度 |
| 多维数组 | 行优先存储,传参需指定除第一维外的维度 |
| 字符串 | 以 '\0' 结尾的字符数组 |
数组是 C 语言内存模型的入门钥匙。掌握数组与指针的关系、理解连续内存布局,后续学习动态内存分配、结构体数组、指针数组等都会顺畅很多。
DAMO开发者矩阵,由阿里巴巴达摩院和中国互联网协会联合发起,致力于探讨最前沿的技术趋势与应用成果,搭建高质量的交流与分享平台,推动技术创新与产业应用链接,围绕“人工智能与新型计算”构建开放共享的开发者生态。
更多推荐


所有评论(0)