跳到主要内容

C++ 数组初始化

在C++编程中，数组是一种基础且常用的数据结构，用于存储同类型元素的集合。正确初始化数组是避免未定义行为和程序错误的关键步骤。本文将详细介绍C++中数组初始化的各种方法，从最基本的技术到现代C++提供的高级特性。

什么是数组初始化？​

数组初始化是指在创建数组时为其元素赋予初始值的过程。这一步骤对于确保程序正确性至关重要，因为未初始化的数组元素包含垃圾值，可能导致不可预测的程序行为。

数组初始化的基本方法​

1. 声明时初始化​

最直接的方法是在声明数组的同时提供初始值：

cpp
int numbers[5] = {10, 20, 30, 40, 50};

这段代码创建了一个包含5个整数的数组，并分别赋值为10, 20, 30, 40和50。

提示

如果提供的初始值少于数组大小，剩余元素会被自动初始化为0（对于数值类型）或默认值（对于其他类型）。

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

2. 省略数组大小​

如果在初始化时提供了值列表，可以省略数组大小，编译器会根据初始值的数量自动确定：

cpp
int autoSized[] = {1, 2, 3, 4, 5}; // 编译器自动确定大小为5

3. 特定元素初始化​

C++11后，可以使用指定初始化器（designated initializers）来初始化特定位置的元素：

cpp
// C++20特性
int specified[5] = {[1] = 20, [3] = 40};  // 等价于 {0, 20, 0, 40, 0}
警告

指定初始化器是C++20引入的特性，较旧的编译器可能不支持。

4. 全零初始化​

要将数组的所有元素初始化为零，可以使用：

cpp
int allZeros[10] = {}; // 所有元素都初始化为0

现代C++中的初始化方法​

1. 统一初始化（使用花括号）​

C++11引入了统一初始化语法，使用花括号进行初始化：

cpp
int modern[5]{1, 2, 3, 4, 5}; // 不需要等号

2. std::array的初始化​

现代C++推荐使用std::array而非C风格数组，因为它提供了更多的安全性和便利性：

cpp
#include <array>
#include <iostream>

int main() {
    std::array<int, 5> arr = {1, 2, 3, 4, 5};
    
    for(const auto& element : arr) {
        std::cout << element << " ";
    }
    
    return 0;
}

输出：

1 2 3 4 5

3. 使用std::fill初始化​

对于较大的数组，可以使用std::fill算法进行初始化：

cpp
#include <array>
#include <algorithm>
#include <iostream>

int main() {
    std::array<int, 10> arr;
    std::fill(arr.begin(), arr.end(), 42);
    
    for(const auto& element : arr) {
        std::cout << element << " ";
    }
    
    return 0;
}

输出：

42 42 42 42 42 42 42 42 42 42

多维数组的初始化​

多维数组可以看作是"数组的数组"，其初始化方式如下：

1. 二维数组初始化​

cpp
int matrix[3][4] = {
    {1, 2, 3, 4},   // 第一行
    {5, 6, 7, 8},   // 第二行
    {9, 10, 11, 12} // 第三行
};
备注

内层花括号是可选的，但使用它们可以提高代码可读性。

2. 部分初始化多维数组​

cpp
int partialMatrix[3][3] = {
    {1, 2},  // 第一行: {1, 2, 0}
    {3},     // 第二行: {3, 0, 0}
    {}       // 第三行: {0, 0, 0}
};

字符数组（字符串）的初始化​

字符数组有一些特殊的初始化方式：

cpp
char greeting[] = "Hello"; // 等价于 {'H', 'e', 'l', 'l', 'o', '\0'}

编译器会自动添加字符串终止符'\0'，所以实际数组大小是6而非5。

实际应用案例​

案例1：学生成绩统计​

cpp
#include <iostream>
#include <array>
#include <algorithm>
#include <numeric>

int main() {
    // 存储10名学生的成绩
    std::array<double, 10> scores = {85.5, 92.0, 76.5, 88.0, 90.5, 
                                     64.0, 81.5, 93.0, 79.0, 86.5};
    
    // 计算平均分
    double sum = std::accumulate(scores.begin(), scores.end(), 0.0);
    double average = sum / scores.size();
    
    // 找出最高分和最低分
    double maxScore = *std::max_element(scores.begin(), scores.end());
    double minScore = *std::min_element(scores.begin(), scores.end());
    
    // 输出结果
    std::cout << "班级平均分: " << average << std::endl;
    std::cout << "最高分: " << maxScore << std::endl;
    std::cout << "最低分: " << minScore << std::endl;
    
    return 0;
}

输出：

班级平均分: 83.65
最高分: 93
最低分: 64

案例2：图像处理中的像素矩阵​

cpp
#include <iostream>

// 简单的灰度图像反转函数
void invertImage(int image[][3], int rows, int cols) {
    for(int i = 0; i < rows; i++) {
        for(int j = 0; j < cols; j++) {
            // 假设像素值范围是0-255（灰度图像）
            image[i][j] = 255 - image[i][j];
        }
    }
}

int main() {
    // 初始化3x3灰度图像矩阵
    int image[3][3] = {
        {100, 120, 130},
        {110, 140, 150},
        {120, 130, 160}
    };
    
    std::cout << "原始图像:" << std::endl;
    for(int i = 0; i < 3; i++) {
        for(int j = 0; j < 3; j++) {
            std::cout << image[i][j] << " ";
        }
        std::cout << std::endl;
    }
    
    // 反转图像
    invertImage(image, 3, 3);
    
    std::cout << "\n反转后的图像:" << std::endl;
    for(int i = 0; i < 3; i++) {
        for(int j = 0; j < 3; j++) {
            std::cout << image[i][j] << " ";
        }
        std::cout << std::endl;
    }
    
    return 0;
}

输出：

原始图像:
100 120 130 
110 140 150 
120 130 160 

反转后的图像:
155 135 125 
145 115 105 
135 125 95

数组初始化的最佳实践​

  1. 总是初始化数组：避免使用未初始化的值，这会导致未定义行为。

  2. 尽量使用std::array代替C风格数组：std::array提供了边界检查和更多有用的方法。

  3. 对于动态大小的集合，考虑使用std::vector：std::vector可以在运行时调整大小，并提供了类似数组的接口。

  4. 使用适当的初始化语法：根据具体需求选择最合适的初始化方式。

  5. 利用零初始化：当需要将数组元素初始化为默认值时，使用={}语法。

初始化错误和陷阱​

注意

以下是一些常见的初始化错误：

  1. 越界初始化：提供超过数组大小的初始值会导致编译错误。
cpp
int wrong[3] = {1, 2, 3, 4}; // 错误：太多的初始值
  1. 遗忘字符串的空终止符：在手动初始化字符串时忘记添加'\0'。
cpp
char incorrectString[] = {'H', 'e', 'l', 'l', 'o'}; // 缺少 '\0'
char correctString[] = {'H', 'e', 'l', 'l', 'o', '\0'}; // 正确
  1. 混淆数组初始化和赋值：初始化只能在声明时进行，之后需要逐元素赋值。
cpp
int arr[5];
arr = {1, 2, 3, 4, 5}; // 错误：不能用列表直接赋值给数组

总结​

数组初始化是C++编程中的基本但重要的概念。正确初始化数组可以防止许多常见的程序错误，并且现代C++提供了多种灵活且安全的初始化方法。从简单的一维数组到复杂的多维结构，掌握适当的初始化技术对于编写高质量的C++代码至关重要。

强烈建议在实际项目中尽可能使用std::array或std::vector代替传统数组，以获得更好的类型安全性和更多的功能。

练习​

  1. 创建一个包含10个整数的数组，并初始化为1到10。
  2. 创建一个3x3的二维数组，初始化为九九乘法表的前9个结果。
  3. 使用std::array创建一个储存5个字符串的数组，并初始化为你最喜欢的5本书的名称。
  4. 创建一个二维数组表示一个3x3的身份矩阵（对角线为1，其余为0）。
  5. 编写一个程序，初始化一个整数数组，然后计算所有元素的和与平均值。

通过这些练习，你将熟练掌握C++中数组初始化的各种方法，为更高级的编程任务打下坚实的基础。