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. 常见陷阱与注意事项

  1. 数组越界:C 不做边界检查,a[5] 访问长度为 5 的数组属于未定义行为,可能崩溃也可能悄悄改坏其他变量。
  2. 数组不能整体赋值:int b[5]; b = a; 是非法写法,需要用 memcpy 或循环逐个复制。
  3. 数组不能作为函数返回值:函数不能返回局部数组,应返回指针(指向静态/堆内存)或由调用方传入缓冲区。
  4. sizeof 陷阱:数组传参后退化为指针,sizeof(arr) 得到的是指针大小而非数组大小。
  5. 字符串忘记 '\0':手动构造字符数组时若漏掉结尾 '\0',printf("%s") 会越界读取。
  6. 变长数组(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 语言内存模型的入门钥匙。掌握数组与指针的关系、理解连续内存布局,后续学习动态内存分配、结构体数组、指针数组等都会顺畅很多。

Logo

DAMO开发者矩阵,由阿里巴巴达摩院和中国互联网协会联合发起,致力于探讨最前沿的技术趋势与应用成果,搭建高质量的交流与分享平台,推动技术创新与产业应用链接,围绕“人工智能与新型计算”构建开放共享的开发者生态。

更多推荐