C语言指针与数组的深度应用与内存解析

从结果可以看出，arr 和 &arr[0] 指向的是同一块内存地址。这就是数组名的隐式转换特性。

⚠️ 注意事项：

1. 数组名不是真正的指针变量，它是一个地址常量，不能被修改。比如 arr++ 这种写法是非法的。
2. 当数组名作为 sizeof 操作符的参数时，不会发生隐式转换，此时 sizeof(arr) 计算的是整个数组的内存大小。

48.1.2 指针算术运算操作数组元素

指针的算术运算（加减整数）是操作数组的核心技巧。指针每加1，偏移的字节数等于其指向数据类型的大小。 我们可以用指针替代数组下标，实现更高效的数组遍历：

#include <stdio.h>

int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    // 定义指针指向数组首元素
    int *p = arr;
    int i;
    for(i = 0; i < 5; i++) {
        // 指针算术运算：p+i 指向第i个元素
        printf("arr[%d] = %d，*(p+%d) = %d\n", i, arr[i], i, *(p+i));
    }
    return 0;
}

✅ 运行结果：

arr[0] = 10，*(p+0) = 10
arr[1] = 20，*(p+1) = 20
arr[2] = 30，*(p+2) = 30
arr[3] = 40，*(p+3) = 40
arr[4] = 50，*(p+4) = 50

从代码中可以得出结论：arr[i] 等价于 *(arr+i)，也等价于 *(p+i)。

💡 性能技巧：在循环遍历数组时，使用指针操作的效率略高于下标操作。因为下标操作需要计算 arr+i 的地址，而指针可以直接通过自增实现偏移。

48.2 二维数组的指针访问：多维数组的内存布局

二维数组是C语言开发中处理表格数据的常用结构。理解二维数组的内存布局，才能用指针灵活操作它。

48.2.1 二维数组的内存本质

二维数组在内存中是连续存储的，不存在'行'和'列'的物理分隔。比如 int arr[2][3] = {{1,2,3},{4,5,6}}，它的内存布局是：

地址偏移 → 0 4 8 12 16 20
元素值 → 1 2 3 4 5 6

其中每个 int 类型占4个字节，所以相邻元素的地址偏移量为4。

二维数组的数组名 arr 可以看作是指向一维数组的指针。arr 指向第一行的一维数组 arr[0]，arr+1 指向第二行的一维数组 arr[1]。

48.2.2 用指针访问二维数组元素

我们可以通过三种方式访问二维数组的元素：下标法、数组名指针法、普通指针法。

#include <stdio.h>

int main() {
    int arr[2][3] = {{1,2,3},{4,5,6}};
    // 方式1：下标法
    printf("下标法访问：arr[1][2] = %d\n", arr[1][2]);
    // 方式2：数组名指针法：arr[i][j] 等价于 *(*(arr+i)+j)
    printf("数组名指针法：*(*(arr+1)+2) = %d\n", *(*(arr+1)+2));
    // 方式3：普通指针法：将二维数组看作一维数组
    int *p = &arr[0][0];
    printf("普通指针法：*(p+5) = %d\n", *(p+5));
    return 0;
}

✅ 运行结果：

下标法访问：arr[1][2] = 6
数组名指针法：*(*(arr+1)+2) = 6
普通指针法：*(p+5) = 6

⚠️ 注意事项：

1. 二维数组的指针 arr 是指向一维数组的指针，其类型为 int (*)[3]，不能直接赋值给 int * 类型的指针。
2. 只有当普通指针指向二维数组的首元素地址时，才能用 *(p+i) 的方式访问元素。

48.3 实战案例：指针实现数组的高效拷贝与逆序

掌握指针与数组的关联后，我们可以用指针实现更高效的数组操作。下面是两个实际开发中常用的案例。

48.3.1 案例1：指针实现数组拷贝函数

要求：编写一个函数，用指针将源数组的内容拷贝到目标数组，要求不使用下标。

#include <stdio.h>
#include <string.h>

// 数组拷贝函数：src源数组，dest目标数组，len数组长度
void arr_copy(int *src, int *dest, int len) {
    int *p_src = src;
    int *p_dest = dest;
    // 循环拷贝每个元素
    while(len--) {
        *p_dest++ = *p_src++;
    }
}

int main() {
    int src_arr[5] = {1,2,3,4,5};
    int dest_arr[5] = {0};
    int i;
    // 调用拷贝函数
    arr_copy(src_arr, dest_arr, 5);
    // 打印目标数组
    printf("拷贝后的目标数组：");
    for(i = 0; i < 5; i++) {
        printf("%d ", dest_arr[i]);
    }
    return 0;
}

✅ 运行结果：

拷贝后的目标数组：1 2 3 4 5

💡 技巧解析：函数中使用 *p_dest++ = *p_src++，先执行赋值操作，再将两个指针自增，实现了简洁高效的拷贝。

48.3.2 案例2：指针实现数组逆序

要求：编写一个函数，用指针将数组元素逆序排列，要求不使用额外数组空间。

#include <stdio.h>

// 数组逆序函数：arr待逆序数组，len数组长度
void arr_reverse(int *arr, int len) {
    // 指向数组首元素
    int *start = arr;
    // 指向数组尾元素
    int *end = arr + len - 1;
    int temp;
    // 首尾交换，直到指针相遇
    while(start < end) {
        temp = *start;
        *start = *end;
        *end = temp;
        start++;
        end--;
    }
}

int main() {
    int arr[5] = {1,2,3,4,5};
    int i;
    printf("逆序前的数组：");
    for(i = 0; i < 5; i++) {
        printf("%d ", arr[i]);
    }
    // 调用逆序函数
    arr_reverse(arr, 5);
    printf("\n逆序后的数组：");
    for(i = 0; i < 5; i++) {
        printf("%d ", arr[i]);
    }
    return 0;
}

✅ 运行结果：

逆序前的数组：1 2 3 4 5
逆序后的数组：5 4 3 2 1

💡 技巧解析：通过首尾两个指针向中间移动，交换对应位置的元素，空间复杂度为O(1)，是最优的数组逆序实现方式。

48.4 内存视角的总结：指针与数组的核心区别

很多开发者会混淆指针和数组，我们从内存角度总结二者的核心区别：

✅ 本章核心结论：

1. 数组名在表达式中会隐式转换为指向首元素的指针，但它不是真正的指针变量。
2. arr[i] 等价于 *(arr+i)，指针算术运算是操作数组的高效方式。
3. 二维数组在内存中连续存储，可通过指向一维数组的指针或普通指针访问。