C++（数组退化为指针与指针算术）

目录

• 1. 一维数组
  • 1.1 数组退化
  • 1.2 指针算术
    • 1.2.1 arr 是指向第一个元素的地址
    • 1.2.2 arr[i] 表示什么？
• 2. 二维数组
  • 2.1数组退化
  • 2.2 示例解释
  • 2.3 总结

1. 一维数组

#include <iostream>

// 函数声明，形参为一个数组和一个整数
void printArray(int arr[], int size) {
    // 遍历数组并打印每个元素
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
}

int main() {
    // 定义一个数组并初始化
    int arr[5] = {1, 2, 3, 4, 5};
    // 调用函数，传递数组和数组大小
    printArray(arr, 5);
    
    return 0;
}

1.1 数组退化

在C++中，当我们定义一个函数参数为数组时，比如 void printArray(int arr[], int size)，数组参数 int arr[] 实际上被解释为指向数组第一个元素的指针，即 int* arr。这是因为在C++中，函数参数不能真正地是数组，数组参数会自动退化为指向其第一个元素的指针。这种行为称为“数组退化为指针”。因此，在函数 printArray 中，int arr[] 和 int* arr 是等价的。

1.2 指针算术

1.2.1 arr 是指向第一个元素的地址

当你传递数组 arr 给函数 printArray 时，传递的实际上是指向数组第一个元素的指针。对于数组 int arr[5] = {1, 2, 3, 4, 5};，数组名 arr 在传递时等价于指针 &arr[0]，即数组第一个元素的地址。

1.2.2 arr[i] 表示什么？

在 printArray 函数中，当你使用 arr[i] 时，C++ 编译器会将其解释为指针算术和解引用操作。具体来说：

• arr 是一个指向 int 类型的指针，指向数组的第一个元素。
• i 是一个整数索引，用于访问数组中的元素。

表达式 arr[i] 可以分解为以下步骤：

1. 指针算术：arr + i 计算指针 arr 加上偏移量 i。由于 arr 是一个 int* 类型的指针，加上 i 后得到一个新的指针，指向数组中的第 i 个元素。指针算术会自动根据指针类型调整偏移量。例如，如果 arr 是 int* 类型，每次增加 1 意味着增加 sizeof(int) 字节。
2. 解引用：*(arr + i) 解引用该指针，访问指针所指向的内存位置的值，即数组中的第 i 个元素。

所以，arr[i] 实际上等价于 *(arr + i)。

2. 二维数组

#include <iostream>

// 函数声明，形参为一个二维数组和一个整数
void print2DArray(int arr[][3], int rows) {
    // 遍历二维数组并打印每个元素
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < 3; ++j) {
            std::cout << arr[i][j] << " ";
        }
    }
}

int main() {
    // 定义一个二维数组并初始化
    int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};
    // 调用函数，传递二维数组和行数
    print2DArray(arr, 2);
    
    return 0;
}

2.1数组退化

二维数组退化：二维数组 arr[2][3] 在传递给函数时，会退化为指向包含3个整数的数组的指针，即 int (*arr)[3]。这意味着 arr 是一个指向 int[3] 类型数组的指针。

访问元素：

• arr[i]：指向第 i 行的数组，类型是 int[3]。
• arr[i][j]：指向第 i 行第 j 列的元素。根据指针算术和解引用操作，这个表达式可以分解为 *(*(arr + i) + j)。
  • arr + i：指向第 i 行的指针，类型是 int (*)[3]。
  • *(arr + i)：指向第 i 行的数组，类型是 int[3]。
  • *(arr + i) + j：指向第 i 行第 j 列的元素的指针，类型是 int*。
  • *(*(arr + i) + j)：解引用这个指针，得到第 i 行第 j 列的元素。

2.2 示例解释

假设 arr 是 int arr[2][3] = {{1, 2, 3}, {4, 5, 6}} 并且 rows 是 2：

• 外层循环 i：
  • 当 i = 0 时：
    • 内层循环 j：
      • 当 j = 0 时：
        • arr[0][0] 等价于 *(*(arr + 0) + 0)，值是 1。
      • 当 j = 1 时：
        • arr[0][1] 等价于 *(*(arr + 0) + 1)，值是 2。
      • 当 j = 2 时：
        • arr[0][2] 等价于 *(*(arr + 0) + 2)，值是 3。
  • 当 i = 1 时：
    • 内层循环 j：
      • 当 j = 0 时：
        • arr[1][0] 等价于 *(*(arr + 1) + 0)，值是 4。
      • 当 j = 1 时：
        • arr[1][1] 等价于 *(*(arr + 1) + 1)，值是 5。
      • 当 j = 2 时：
        • arr[1][2] 等价于 *(*(arr + 1) + 2)，值是 6。

最终，print2DArray 函数会打印二维数组的所有元素：

1 2 3 
4 5 6 

2.3 总结

• 在函数参数中，二维数组 int arr[][3] 退化为 int (*arr)[3]，即指向包含3个整数的数组的指针。
• arr[i] 指向第 i 行的数组，类型是 int[3]。
• arr[i][j] 等价于 *(*(arr + i) + j)，访问第 i 行第 j 列的元素。
• 通过双重循环，可以遍历和打印二维数组中的所有元素。