C++基础篇（二）基本数组及示例

一、一维数组

1、定义和初始化

在 C++ 中，可以使用下面的语法定义一个一维数组：

type arrayName [ arraySize ];

其中，type 是数组元素的类型，arrayName 是数组的名称，arraySize 是数组中元素的数量。

例如，下面的代码定义了一个包含 5 个整数的一维数组：

int numbers[5];

在定义数组时，可以同时初始化数组中的元素。例如：

int numbers[5] = {1, 2, 3, 4, 5};

也可以只初始化部分元素，未初始化的元素将被自动设置为默认值（通常为 0）。例如：

int numbers[5] = {1, 2}; // 等价于 {1, 2, 0, 0, 0}

如果在定义数组时不指定数组大小，则编译器会根据初始化元素的数量自动确定数组大小。例如：

int numbers[] = {1, 2, 3, 4, 5}; // 等价于 int numbers[5] = {1, 2, 3, 4, 5};

2、访问和修改

在定义了一个一维数组之后，可以通过下标运算符 [] 访问或修改数组中的元素。下标从 0 开始，最大值为 arraySize - 1。例如：

int numbers[5] = {1, 2, 3, 4, 5};
std::cout << numbers[0] << std::endl; // 输出第一个元素
numbers[1] = 42; // 修改第二个元素

注意，在访问或修改数组中的元素时，必须确保下标在合法范围内。否则会发生未定义行为。

除了使用下标运算符访问或修改数组中的元素外，还可以使用指针进行操作。因为在 C++ 中，数组名可以理解为指向数组第一个元素的指针，直接输出数组名是数组的首元素地址（16进制）。例如：

int numbers[5] = {1, 2, 3, 4, 5};
std::cout << numbers << std::endl; // 输出数组首地址
std::cout << *numbers << std::endl; // 输出第一个元素
*(numbers + 1) = 42; // 修改第二个元素

此外，在 C++ 中还可以使用范围 for 循环遍历一维数组中的所有元素。例如：

int numbers[5] = {1, 2, 3, 4, 5};
for (int n : numbers) {
    std::cout << n << std::endl; // 输出每个元素
}

3、元素逆置和冒泡排序

①元素逆置
用双指针算法将其中的元素逆置。

#include <iostream>

int main() {
    int numbers[] = {3,2,1,4,5};
    int size = sizeof(numbers) / sizeof(int);//将整个数组占用内存大小除单个数组内存大小得到数组长度

    // 双指针算法
    int* left = numbers;
    int* right = numbers + size - 1;
    while (left < right) {
        int temp = *left;//暂存值左值
        *left = *right;//将较大值赋给左边元素
        *right = temp;//较小值赋给右边元素
        left++;
        right--;
    }

    // 输出结果
    for (int n : numbers) {
        std::cout << n << " ";
    }
    std::cout << std::endl;

    return 0;
}

②冒泡排序

#include <iostream>

int main() {
    int numbers[] = {4, 5, 2, 3，1};
    int size = sizeof(numbers) / sizeof(int);

    // 冒泡排序
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (numbers[j] > numbers[j + 1]) {
                int temp = numbers[j];
                numbers[j] = numbers[j + 1];
                numbers[j + 1] = temp;
            }
        }
    }

    // 输出结果
    for (int n : numbers) {
        std::cout << n << " ";
    }
    std::cout << std::endl;

    return 0;
}

二、二维数组（用指针进行访问与修改）

1、定义和初始化

二维数组是由多个一维数组组成的数组。在 C++ 中，可以使用下面的语法定义一个二维数组：

type arrayName [ xSize ][ ySize ];

其中，type 是数组元素的类型，arrayName 是数组的名称，xSize 和 ySize 分别表示二维数组中第一维和第二维的大小。

例如，下面的代码定义了一个包含两行三列整数的二维数组：

int matrix[2][3];

与一维数组类似，在定义二维数组时也可以同时初始化其中的元素。例如：

int matrix[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

也可以只初始化部分元素，未初始化的元素将被自动设置为默认值（通常为 0）。例如：

int matrix[2][3] = {
    {1},
    {4}
}; // 等价于 {{1, 0, 0}, {4, 0, 0}}

如果在定义二维数组时不指定第一维和第二维的大小，则编译器会根据初始化元素的数量自动确定它们。例如：

int matrix[][3] = {
    {1, 2, 3},
    {4, 5, 6}
}; // 等价于 int matrix[2][3] = {{1, 2, 3}, {4, 5, 6}};

2、访问与修改

在定义了一个二维数组之后，可以通过两个下标运算符 [][] 访问或修改其中的元素。第一个下标表示行号（从上到下），第二个下标表示列号（从左到右）。例如：

int matrix[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};
std::cout << matrix[0][1] << std::endl; // 输出第一行第二列的元素
matrix[1][2] = 42; // 修改第二行第三列的元素

注意，在访问或修改二维数组中的元素时，必须确保下标在合法范围内。否则会发生未定义行为。

除了使用下标运算符访问或修改二维数组中的元素外，还可以使用指针进行操作。因为在 C++ 中，二维数组名实际上是一个指向一维数组的指针，进行解引用后得到的是一个一维数组首元素的指针，再次进行解引用得到的才是首元素的值。例如：

int matrix[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};
std::cout << **matrix << std::endl; // 输出第一行第一列的元素
*(*(matrix + 1) + 2) = 42; // 修改第二行第三列的元素

此外，在 C++ 中还可以使用嵌套循环遍历二维数组中的所有元素。例如：

int matrix[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};
for (auto& row : matrix) {
    for (int n : row) {
        std::cout << n << std::endl; // 输出每个元素
    }
}

三、更高维度的数组

1、三维数组

三维数组是由多个二维数组组成的数组。下面的代码定义了一个包含两个二维数组的三维数组，每个二维数组都包含两行三列整数：

int matrix[2][2][3] = {
    {
        {1, 2, 3},
        {4, 5, 6}
    },
    {
        {7, 8, 9},
        {10, 11, 12}
    }
};
std::cout << matrix[0][1][2] << std::endl; // 输出第一个二维数组中第二行第三列的元素
matrix[1][0][1] = 42; // 修改第二个二维数组中第一行第二列的元素

//遍历三维数组
for (auto& twoDArray : matrix) {
    for (auto& row : twoDArray) {
        for (int n : row) {
            std::cout << n << " ";
        }
    }
}

三维数组名实际上是一个指向二维数组的指针。对它进行一次解引用操作时，将会得到一个二维数组名，它也是一个指针，指向一维数组。再次对它进行解引用操作时，会得到一个一维数组名，它也是一个指针，指向一维数组首元素。最后对它进行解引用操作，将会得到一维数组首元素的值，因此这里需要三个解引用运算符。

//用指针来访问和修改三维数组
std::cout << *(*(*(matrix + 1) + 0) + 1) << std::endl; // 输出第二个二维数组中第一行第二列的元素
*(*(*(matrix + 1) + 0) + 1) = 42; // 修改第二个二维数组中第一行第二列的元素

在上面的代码中，matrix 是一个指向二维数组 {{1, 2, 3}, {4, 5, 6}} 的指针。对它进行一次解引用操作并加上偏移量 1 后，将会得到另一个二维数组名 {{7, 8, 9}, {10, 11, 12}}，再次对它进行解引用操作并加上偏移量 0 ，得到一个一维数组名 {7, 8, 9}。最后对它进行解引用操作并加上偏移量 1 后，得到一维数组中第二个元素的值 8

2、高维数组

四维数组可以看成由多个三维数组所组成的数组，依此类推，高维数组可以看成由多个低一维数组所组成的数组。