【C语言入门】数组下标访问：数组名[i]`等价于 *(数组名+i)

引言：为什么要理解数组下标与指针的等价性？

C 语言的核心魅力之一是 “接近底层的灵活性”，而数组与指针的关系是这种灵活性的典型体现。掌握arr[i]与*(arr+i)的等价性，不仅能帮你读懂复杂代码，还能理解内存操作的本质，为后续学习动态内存分配（malloc）、字符串处理、多维数组甚至数据结构（如链表、树）打下基础。

一、数组的内存布局：连续存储的本质

要理解arr[i]与*(arr+i)的关系，首先需要明确数组在内存中的存储方式。

1.1 数组的物理存储特性

C 语言中，数组是同类型元素的连续内存块。例如：

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

这行代码会在内存中分配一块连续的空间，存放 5 个int类型的元素。假设每个int占 4 字节（取决于编译器和系统），则数组总占用空间为5×4=20字节。

1.2 数组名的本质：起始地址的 “指针常量”

在 C 语言中，数组名arr代表数组的起始地址（即第一个元素arr[0]的地址）。可以用&arr[0]验证这一点：

#include <stdio.h>
int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    printf("arr的地址: %p\n", arr);       // 输出起始地址
    printf("arr[0]的地址: %p\n", &arr[0]); // 输出相同地址
    return 0;
}

输出结果（示例）：

arr的地址: 0x7ffd6b4c6a50  
arr[0]的地址: 0x7ffd6b4c6a50

这说明arr和&arr[0]的值完全相同 —— 数组名是数组起始地址的指针常量（不能被重新赋值，如arr = &x会报错）。

1.3 元素地址的计算规律

由于数组是连续存储的，第i个元素的地址可以通过起始地址加上i×元素大小得到。例如：

• arr[0]的地址 = 起始地址（arr）
• arr[1]的地址 = 起始地址 + 1×4 字节（假设int占 4 字节）
• arr[i]的地址 = 起始地址 + i×4 字节

二、指针运算的数学本质：偏移量的单位是 “元素大小”

C 语言的指针运算与普通整数运算不同：指针加 1 不是加 1 字节，而是加 1 个元素大小的字节数。这是理解arr[i]与*(arr+i)等价性的关键。

2.1 指针的 “步长” 由元素类型决定

指针变量的类型决定了它的 “步长”（即指针加 1 时实际移动的字节数）。例如：

• int*类型的指针加 1，移动sizeof(int)字节（通常 4 字节）。
• char*类型的指针加 1，移动sizeof(char)字节（1 字节）。
• double*类型的指针加 1，移动sizeof(double)字节（通常 8 字节）。

2.2 示例：指针加 i 的计算过程

假设arr的起始地址是0x1000（16 进制），且int占 4 字节：

• arr + 0 = 0x1000（指向arr[0]）
• arr + 1 = 0x1000 + 4 = 0x1004（指向arr[1]）
• arr + 2 = 0x1000 + 8 = 0x1008（指向arr[2]）
• arr + i = 0x1000 + i×4（指向arr[i]）

2.3 结论：指针运算的本质是 “元素偏移”

指针加i的结果是：起始地址 + i× 元素大小，这正好是第i个元素的地址。因此，arr + i等价于&arr[i]。

三、下标访问的底层实现：arr[i]是*(arr+i)的语法糖

C 语言的编译器在处理数组下标访问arr[i]时，会将其转换为*(arr + i)的形式。这种转换是 C 语言设计时的 “语法糖”，目的是让代码更符合人类的思维习惯（直接通过下标定位元素）。

3.1 编译器的转换规则

当你写下arr[i]时，编译器会执行以下步骤：

1. 计算arr + i：得到第i个元素的地址（即&arr[i]）。
2. 对该地址进行解引用（*操作）：获取该地址处的内存值（即arr[i]的值）。

3.2 示例：用指针直接操作数组

通过指针变量p指向数组arr，可以验证p[i]与*(p+i)的等价性：

#include <stdio.h>
int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int* p = arr; // p指向数组起始地址

    // 两种方式访问元素
    printf("arr[2] = %d\n", arr[2]);       // 输出30
    printf("*(arr+2) = %d\n", *(arr+2));   // 输出30
    printf("p[2] = %d\n", p[2]);           // 输出30
    printf("*(p+2) = %d\n", *(p+2));       // 输出30

    return 0;
}

输出结果：

arr[2] = 30  
*(arr+2) = 30  
p[2] = 30  
*(p+2) = 30  

这说明无论是数组名还是指针变量，下标访问和指针解引用的结果完全一致。

3.3 数学上的等价性：i[arr]的特殊写法

由于加法交换律（arr + i = i + arr），C 语言允许一种 “反直觉” 的写法：i[arr]，它等价于arr[i]和*(arr + i)。例如：

#include <stdio.h>
int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    printf("2[arr] = %d\n", 2[arr]); // 等价于arr[2]
    return 0;
}

输出结果：

2[arr] = 30

这种写法虽然不常见，但能进一步证明arr[i]的本质是*(arr + i)—— 下标只是一个 “偏移量”，可以写在数组名的左边或右边（但实际开发中不建议这么写，会降低代码可读性）。

四、指针与数组的关系：为什么数组能当指针用？

C 语言中，数组和指针的关系如此紧密，以至于很多初学者会混淆两者。实际上，数组不是指针，但数组名可以隐式转换为指针。

4.1 数组名与指针变量的区别

虽然数组名arr的值等于&arr[0]，但它与指针变量（如int* p = arr中的p）有本质区别：

• 数组名是指针常量：不能被重新赋值（如arr = &x会编译报错）。
• 指针变量是指针变量：可以被重新赋值（如p = &x是合法的）。

4.2 数组作为函数参数时的 “退化”

当数组作为函数参数传递时，编译器会将其 “退化” 为指针。例如：

void print_array(int arr[], int len) {
    for (int i = 0; i < len; i++) {
        printf("%d ", arr[i]); // 等价于*(arr + i)
    }
}

这里的int arr[]本质上是int* arr—— 函数参数中的数组声明会被编译器视为指针。因此，函数内部无法通过sizeof(arr)获取数组的实际大小（sizeof会返回指针的大小，而不是数组总大小）。

4.3 动态内存分配与数组的关系

通过malloc动态分配内存后得到的指针，与数组的行为几乎完全一致。例如：

#include <stdio.h>
#include <stdlib.h>

int main() {
    int* arr = (int*)malloc(5 * sizeof(int)); // 分配5个int的空间
    if (arr == NULL) {
        return -1;
    }

    // 像数组一样操作指针
    arr[0] = 10;
    arr[1] = 20;
    *(arr + 2) = 30; // 等价于arr[2] = 30

    printf("arr[2] = %d\n", arr[2]); // 输出30

    free(arr); // 释放内存
    return 0;
}

这里arr是一个指针变量，但可以通过下标arr[i]或*(arr+i)访问内存 —— 因为动态分配的内存也是连续的，与数组的存储方式一致。

五、实例验证：通过调试看内存地址

为了更直观地理解arr[i]与*(arr+i)的等价性，我们可以通过调试工具查看内存地址和值的对应关系。

5.1 示例代码

#include <stdio.h>

int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int i = 2;

    // 打印地址
    printf("arr的地址: %p\n", (void*)arr);
    printf("arr + i的地址: %p\n", (void*)(arr + i));
    printf("&arr[i]的地址: %p\n", (void*)&arr[i]);

    // 打印值
    printf("arr[i]的值: %d\n", arr[i]);
    printf("*(arr + i)的值: %d\n", *(arr + i));

    return 0;
}

5.2 输出结果（示例）

arr的地址: 0x7ffd6b4c6a50  
arr + i的地址: 0x7ffd6b4c6a58  
&arr[i]的地址: 0x7ffd6b4c6a58  
arr[i]的值: 30  
*(arr + i)的值: 30  

5.3 结果分析

• arr的地址是0x7ffd6b4c6a50（起始地址）。
• i=2时，arr + i的地址是0x7ffd6b4c6a50 + 2×4 = 0x7ffd6b4c6a58（假设int占 4 字节）。
• &arr[i]的地址与arr + i完全一致。
• arr[i]和*(arr + i)的值都是 30（arr[2]的元素值）。

六、注意事项：避免常见错误

理解arr[i]与*(arr+i)的等价性后，还需要注意以下边界问题，避免写出危险或错误的代码。

6.1 数组越界访问

由于 C 语言不做数组越界检查，arr[i]或*(arr+i)可能访问到数组外的内存（称为 “缓冲区溢出”）。例如：

int arr[5] = {10, 20, 30, 40, 50};
printf("%d\n", arr[5]); // 越界访问（数组下标0~4）

此时arr[5]等价于*(arr + 5)，访问的是数组后面的内存（可能是其他变量或未初始化的区域），导致不可预测的结果（如程序崩溃、数据错误）。

6.2 指针类型与数组元素类型不匹配

如果指针类型与数组元素类型不匹配，指针运算的步长会错误，导致地址计算错误。例如：

int arr[5] = {10, 20, 30, 40, 50};
char* p = (char*)arr; // 错误：将int数组的地址赋给char指针

// 错误计算：p + 1 移动1字节（而非4字节）
printf("%d\n", *(p + 1)); // 输出的是arr[0]的第二个字节（可能是乱码）

6.3 数组名不能被重新赋值

数组名是指针常量，不能被重新赋值。例如：

int arr[5] = {10, 20, 30, 40, 50};
arr = arr + 1; // 错误：数组名是常量，不能修改

七、扩展应用：在实际开发中的价值

理解arr[i]与*(arr+i)的等价性，能帮助你更高效地处理以下场景：

7.1 字符串处理

C 语言的字符串本质是char数组，末尾以\0结尾。通过指针操作字符串是常见技巧：

#include <stdio.h>

void print_string(char* str) {
    while (*str != '\0') { // 等价于str[0] != '\0'
        printf("%c", *str); // 等价于str[0]
        str++; // 指针后移1个char（1字节）
    }
}

int main() {
    char str[] = "Hello";
    print_string(str); // 输出Hello
    return 0;
}

7.2 多维数组的访问

多维数组在内存中是 “按行连续存储” 的。例如二维数组int arr[3][4]可以视为 3 个一维数组（每个一维数组有 4 个元素）。此时，arr[i][j]等价于*(*(arr + i) + j)：

#include <stdio.h>

int main() {
    int arr[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    // arr[i][j] 等价于 *(*(arr + i) + j)
    printf("arr[1][2] = %d\n", arr[1][2]);           // 输出7
    printf("*(*(arr + 1) + 2) = %d\n", *(*(arr + 1) + 2)); // 输出7

    return 0;
}

7.3 动态内存分配（malloc）

动态分配多维数组时，需要手动管理内存的连续性，此时指针运算的知识至关重要。例如分配一个 3×4 的二维数组：

#include <stdio.h>
#include <stdlib.h>

int main() {
    // 分配3行的指针数组
    int** arr = (int**)malloc(3 * sizeof(int*));
    // 为每行分配4个int的空间
    for (int i = 0; i < 3; i++) {
        arr[i] = (int*)malloc(4 * sizeof(int));
    }

    // 赋值
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            arr[i][j] = i * 4 + j + 1; // 等价于*(*(arr + i) + j) = ...
        }
    }

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

    // 释放内存（注意顺序）
    for (int i = 0; i < 3; i++) {
        free(arr[i]);
    }
    free(arr);

    return 0;
}

八、历史背景：C 语言设计的初衷

C 语言由丹尼斯・里奇（Dennis Ritchie）在 1970 年代为开发 UNIX 系统设计。当时的计算机内存非常有限，因此 C 语言追求效率和接近硬件的控制能力。数组与指针的等价性设计正是这种理念的体现：

• 避免额外开销：数组下标访问直接转换为指针运算，不需要额外的计算或函数调用，保证了效率。
• 灵活性：允许通过指针直接操作内存，满足系统编程（如驱动开发、内存管理）的需求。

形象化解释：用 “快递柜” 理解数组下标与指针的关系

我们可以把数组想象成一排编号的快递柜，每个柜子里装着你的快递（数组元素）。现在用这个场景理解两个关键概念：

1. 数组名 = 快递柜的 “门牌号”

假设快递柜有 10 个格子，统一放在 “幸福路 100 号” 的墙面上。这里的 “幸福路 100 号” 就是数组名（比如int arr[10]中的arr），它代表这排快递柜的起始地址—— 就像快递柜的 “门牌号”，告诉别人 “快递柜从这里开始”。

2. 下标[i] = “第 i+1 个柜子” 的编号

快递柜的格子是从 0 开始编号的（就像 C 语言数组下标从 0 开始）：第 0 号格子、第 1 号格子…… 第 9 号格子。
如果我要找第 3 个格子（下标i=3），直接说 “幸福路 100 号的 3 号格子”（即arr[3]）就能拿到快递。

3. *(数组名+i) = “从门牌号出发，往后走 i 步”

另一种找 3 号格子的方式是：从 “幸福路 100 号”（arr）出发，往后走 3 步（每步的距离等于一个格子的宽度），到达的位置就是 3 号格子的地址。这时候 “拆开” 这个地址（解引用*），就能拿到里面的快递。
这就是*(arr + 3)的含义 —— 和arr[3]完全等价。

总结：两种方式本质相同

无论是直接说 “第 i 号格子”（arr[i]），还是说 “从起始地址出发走 i 步再拆开”（*(arr+i)），最终都是在访问同一个快递柜格子。C 语言的数组下标访问本质上是指针运算的语法糖，目的是让代码更直观。