C++ 数组

数组是相同类型元素的集合，存储在连续的内存位置中。数组是 C++ 中最基本的数据结构之一。

1. 数组的声明和初始化

1.1 声明数组

类型 数组名[大小];

示例

#include <iostream>

int main() {
    int numbers[5];  // 声明一个包含 5 个整数的数组
    double scores[10];  // 声明一个包含 10 个双精度浮点数的数组
    char name[20];  // 声明一个包含 20 个字符的数组
    
    return 0;
}

1.2 初始化数组

#include <iostream>

int main() {
    // 初始化所有元素
    int numbers[5] = {1, 2, 3, 4, 5};
    
    // 部分初始化（剩余元素初始化为 0）
    int scores[5] = {90, 85, 95};
    
    // 省略数组大小（由初始化列表决定）
    int values[] = {10, 20, 30, 40, 50};
    
    // 初始化为 0
    int zeros[5] = {0};
    
    return 0;
}

2. 访问数组元素

数组元素通过索引访问，索引从 0 开始。

2.1 示例

#include <iostream>

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};
    
    // 访问数组元素
    std::cout << "第一个元素: " << numbers[0] << std::endl;
    std::cout << "第二个元素: " << numbers[1] << std::endl;
    std::cout << "第三个元素: " << numbers[2] << std::endl;
    
    // 修改数组元素
    numbers[0] = 100;
    std::cout << "修改后的第一个元素: " << numbers[0] << std::endl;
    
    return 0;
}

3. 遍历数组

可以使用循环遍历数组中的所有元素。

3.1 使用 for 循环

#include <iostream>

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};
    
    // 使用 for 循环遍历数组
    for (int i = 0; i < 5; i++) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

3.2 使用范围 for 循环（C++11）

#include <iostream>

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};
    
    // 使用范围 for 循环遍历数组
    for (int num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

4. 数组的大小

可以使用sizeof运算符获取数组的大小。

4.1 示例

#include <iostream>

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};
    
    // 获取数组的大小（字节数）
    std::cout << "数组的大小（字节）: " << sizeof(numbers) << std::endl;
    
    // 获取数组的元素个数
    int size = sizeof(numbers) / sizeof(numbers[0]);
    std::cout << "数组的元素个数: " << size << std::endl;
    
    return 0;
}

5. 多维数组

多维数组是数组的数组，最常见的是二维数组。

5.1 二维数组

#include <iostream>

int main() {
    // 声明并初始化二维数组
    int matrix[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    
    // 访问二维数组元素
    std::cout << "matrix[0][0] = " << matrix[0][0] << std::endl;
    std::cout << "matrix[1][1] = " << matrix[1][1] << std::endl;
    std::cout << "matrix[2][2] = " << matrix[2][2] << std::endl;
    
    // 遍历二维数组
    std::cout << "\n二维数组:" << std::endl;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            std::cout << matrix[i][j] << " ";
        }
        std::cout << std::endl;
    }
    
    return 0;
}

6. 数组作为函数参数

数组可以作为函数参数传递。

6.1 示例

#include <iostream>

// 函数声明
void print_array(int arr[], int size);
int sum_array(int arr[], int size);

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};
    
    // 打印数组
    print_array(numbers, 5);
    
    // 计算数组的和
    int sum = sum_array(numbers, 5);
    std::cout << "数组的和: " << sum << std::endl;
    
    return 0;
}

// 打印数组
void print_array(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}

// 计算数组的和
int sum_array(int arr[], int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += arr[i];
    }
    return sum;
}

7. 数组的常见操作

7.1 查找数组中的最大值和最小值

#include <iostream>

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};
    
    int max = numbers[0];
    int min = numbers[0];
    
    for (int i = 1; i < 5; i++) {
        if (numbers[i] > max) {
            max = numbers[i];
        }
        if (numbers[i] < min) {
            min = numbers[i];
        }
    }
    
    std::cout << "最大值: " << max << std::endl;
    std::cout << "最小值: " << min << std::endl;
    
    return 0;
}

7.2 数组排序（冒泡排序）

#include <iostream>

int main() {
    int numbers[5] = {50, 40, 30, 20, 10};
    
    // 冒泡排序
    for (int i = 0; i < 5 - 1; i++) {
        for (int j = 0; j < 5 - i - 1; j++) {
            if (numbers[j] > numbers[j + 1]) {
                int temp = numbers[j];
                numbers[j] = numbers[j + 1];
                numbers[j + 1] = temp;
            }
        }
    }
    
    // 打印排序后的数组
    for (int i = 0; i < 5; i++) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

7.3 数组反转

#include <iostream>

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};
    
    // 数组反转
    for (int i = 0; i < 5 / 2; i++) {
        int temp = numbers[i];
        numbers[i] = numbers[5 - 1 - i];
        numbers[5 - 1 - i] = temp;
    }
    
    // 打印反转后的数组
    for (int i = 0; i < 5; i++) {
        std::cout << numbers[i] << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

8. 字符数组

字符数组用于存储字符串。

8.1 示例

#include <iostream>

int main() {
    // 字符数组
    char name[] = "Hello";
    
    // 打印字符数组
    std::cout << name << std::endl;
    
    // 遍历字符数组
    for (int i = 0; name[i] != '\0'; i++) {
        std::cout << name[i] << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

9. 数组的注意事项

9.1 数组越界

数组越界访问会导致未定义行为。

#include <iostream>

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};
    
    // 数组越界访问（危险！）
    // std::cout << numbers[5] << std::endl;  // 错误：索引越界
    
    return 0;
}

9.2 数组作为函数参数时退化为指针

当数组作为函数参数时，它会退化为指针，无法获取数组的大小。

#include <iostream>

void function(int arr[]) {
    // sizeof(arr) 返回的是指针的大小，而不是数组的大小
    std::cout << "sizeof(arr) = " << sizeof(arr) << std::endl;
}

int main() {
    int numbers[5] = {10, 20, 30, 40, 50};
    
    function(numbers);
    
    return 0;
}

10. 示例：综合运用

现在，让我们看一个综合运用各种数组操作的例子：

#include <iostream>

// 函数声明
void print_array(int arr[], int size);
int sum_array(int arr[], int size);
void reverse_array(int arr[], int size);
void bubble_sort(int arr[], int size);

int main() {
    // 声明并初始化数组
    int numbers[5] = {50, 40, 30, 20, 10};
    
    // 打印数组
    std::cout << "原始数组: ";
    print_array(numbers, 5);
    
    // 计算数组的和
    int sum = sum_array(numbers, 5);
    std::cout << "数组的和: " << sum << std::endl;
    
    // 数组反转
    reverse_array(numbers, 5);
    std::cout << "反转后的数组: ";
    print_array(numbers, 5);
    
    // 数组排序
    bubble_sort(numbers, 5);
    std::cout << "排序后的数组: ";
    print_array(numbers, 5);
    
    return 0;
}

// 打印数组
void print_array(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}

// 计算数组的和
int sum_array(int arr[], int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += arr[i];
    }
    return sum;
}

// 数组反转
void reverse_array(int arr[], int size) {
    for (int i = 0; i < size / 2; i++) {
        int temp = arr[i];
        arr[i] = arr[size - 1 - i];
        arr[size - 1 - i] = temp;
    }
}

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

小结

C++ 数组包括：

1. 数组的声明和初始化：

   • 声明数组：类型 数组名[大小];
   • 初始化数组：int numbers[5] = {1, 2, 3, 4, 5};

2. 访问数组元素：

   • 通过索引访问：numbers[0]

3. 遍历数组：

   • 使用 for 循环
   • 使用范围 for 循环（C++11）

4. 数组的大小：

   • 使用sizeof运算符获取

5. 多维数组：

   • 二维数组：int matrix[3][3];

6. 数组作为函数参数：

   • 数组退化为指针
   • 需要传递数组的大小

7. 数组的常见操作：

   • 查找最大值和最小值
   • 数组排序
   • 数组反转

8. 字符数组：

   • 用于存储字符串

9. 数组的注意事项：

   • 数组越界访问会导致未定义行为
   • 数组作为函数参数时退化为指针

关键概念：

• 数组索引：从 0 开始
• 数组大小：固定大小，不能动态改变
• 连续内存：数组元素存储在连续的内存位置中

掌握数组是编写 C++ 程序的基础，在后续章节中，我们将学习 C++ 的字符串。