当前位置：首页 > article >正文

C++-----------数组

article 2025/3/1 0:12:21

1. 声明数组

在 C++ 中，数组是存储相同类型元素的集合。可以使用以下语法来声明数组：

#include <iostream>

int main() {
    // 声明一个包含 5 个元素的整型数组
    int myArray[5];
    // 声明一个包含 3 个元素的双精度浮点数数组
    double anotherArray[3];

    return 0;
}

在上述代码中：

int myArray[5]; 声明了一个名为 myArray 的整型数组，其长度为 5。
double anotherArray[3]; 声明了一个名为 anotherArray 的双精度浮点数数组，其长度为 3。

2. 数组元素的选择

使用下标运算符 [] 可以访问数组中的元素。数组的下标从 0 开始，最大下标为 数组长度 - 1。例如：

#include <iostream>

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

    // 访问数组元素
    std::cout << myArray[0] << std::endl; // 输出第一个元素，即 10
    std::cout << myArray[2] << std::endl; // 输出第三个元素，即 30

    // 修改数组元素
    myArray[1] = 25;
    std::cout << myArray[1] << std::endl; // 输出修改后的第二个元素，即 25

    return 0;
}

在这个示例中：

myArray[0] 表示数组的第一个元素。
myArray[2] 表示数组的第三个元素。
myArray[1] = 25; 修改了数组的第二个元素。

3. 数组的静态初始化

静态初始化允许在声明数组时为元素提供初始值。可以使用以下几种方式：

#include <iostream>

int main() {
    // 完全初始化
    int array1[3] = {1, 2, 3};

    // 部分初始化，未初始化的元素会被编译器初始化为 0
    int array2[5] = {4, 5};

    // 字符数组的初始化
    char charArray[] = "Hello";

    std::cout << array1[0] << " " << array1[1] << " " << array1[2] << std::endl;
    std::cout << array2[0] << " " << array2[1] << " " << array2[2] << " " << array2[3] << " " << array2[4] << std::endl;
    std::cout << charArray << std::endl;

    return 0;
}

在上述代码中：

int array1[3] = {1, 2, 3}; 对数组进行了完全初始化。
int array2[5] = {4, 5}; 进行了部分初始化，未初始化的元素（array2[2]、array2[3] 和 array2[4]）将被初始化为 0。
char charArray[] = "Hello"; 字符数组可以直接使用字符串常量进行初始化，编译器会自动添加字符串结束符 '\0'。

4. 有效容量和分配容量

有效容量：是指数组中实际存储元素的数量。对于静态数组，其有效容量就是声明时指定的元素数量，例如 int myArray[5] 的有效容量是 5。
分配容量：对于静态数组，分配容量与有效容量相同。

以下是一个使用 sizeof 运算符计算数组有效容量的示例：

#include <iostream>

int main() {
    int myArray[5] = {10, 20, 30, 40, 50};
    int size = sizeof(myArray) / sizeof(myArray[0]);
    std::cout << "有效容量: " << size << std::endl; // 输出有效容量，应为 5

    return 0;
}

在这个示例中，sizeof(myArray) 得到数组 myArray 占用的总字节数，sizeof(myArray[0]) 得到数组中一个元素占用的字节数，相除得到元素的数量。

5. 指针和数组的分配关系

在 C++ 中，数组名可以隐式转换为指向其第一个元素的指针。以下是指针和数组之间关系的一些示例：

#include <iostream>

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

    // 数组名转换为指针
    int* ptr = myArray;
    std::cout << *ptr << std::endl; // 输出第一个元素，即 10

    // 指针运算
    ptr++;
    std::cout << *ptr << std::endl; // 输出第二个元素，即 20

    // 另一种指针表示法
    std::cout << *(myArray + 2) << std::endl; // 输出第三个元素，即 30

    // 使用指针遍历数组
    for (int* p = myArray; p < myArray + 5; ++p) {
        std::cout << *p << " ";
    }
    std::cout << std::endl;

    return 0;
}

在上述代码中：

int* ptr = myArray; 将数组名 myArray 转换为指向其第一个元素的指针。
ptr++; 使指针指向下一个元素，因为指针算术运算会根据元素的大小自动调整偏移量。
*(myArray + 2) 与 myArray[2] 等价，使用指针算术运算访问数组元素。
循环 for (int* p = myArray; p < myArray + 5; ++p) 使用指针遍历数组。

6. 动态数组

除了静态数组，C++ 还支持使用 new 和 delete[] 运算符创建动态数组：

#include <iostream>

int main() {
    // 动态分配数组
    int* dynamicArray = new int[5];

    // 初始化动态数组元素
    for (int i = 0; i < 5; ++i) {
        dynamicArray[i] = i * 10;
    }

    // 访问动态数组元素
    for (int i = 0; i < 5; ++i) {
        std::cout << dynamicArray[i] << " ";
    }
    std::cout << std::endl;

    // 释放动态数组内存
    delete[] dynamicArray;

    return 0;
}

在这个示例中：

int* dynamicArray = new int[5]; 使用 new 运算符在堆上分配了一个包含 5 个元素的整型数组。
可以像操作静态数组一样使用 [] 运算符访问元素。
delete[] dynamicArray; 使用 delete[] 运算符释放动态分配的内存，防止内存泄漏。

需要注意的是，对于动态数组，使用完后必须使用 delete[] 释放内存，否则会导致内存泄漏。而静态数组由编译器自动管理内存，无需手动释放。

7. 多维数组

C++ 还支持多维数组，以下是一个二维数组的示例：

#include <iostream>

int main() {
    // 声明一个二维数组
    int twoDArray[3][4] = {{1, 2, 3, 4},
                       {5, 6, 7, 8},
                       {9, 10, 11, 12}};

    // 访问二维数组元素
    std::cout << twoDArray[1][2] << std::endl; // 输出第二行第三列元素，即 7

    // 使用指针遍历二维数组
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 4; ++j) {
            std::cout << twoDArray[i][j] << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}