C++ std::array和C数组的区别：为什么推荐用std::array

C 数组是 C 和 C++ 中的基础数据结构，但 C++ 标准库提供了 std::array，一个更现代、更安全的替代品。本文将对比两者，并解释为什么在 C++ 中优先选择 std::array。

什么是 C 数组？

C 数组是一种原始的、低级的数据结构，它表示一块连续的内存空间，用于存储相同类型的元素。其大小在编译时必须确定，并且是固定的。

// 声明一个包含5个int类型元素的C数组
int c_arr[5];

C 数组的主要特点包括：

• 固定大小：大小在声明时确定，运行时无法改变。
• 内存布局：元素在内存中连续存储。
• 访问方式：通过下标 [] 访问元素。
• 无边界检查：下标越界访问是未定义行为，可能导致程序崩溃或数据损坏。
• 类型信息：数组的大小不是其类型的一部分。int[5] 和 int[10] 在类型系统中被视为不同的类型，但编译器通常不会利用这一点进行严格的类型检查。

什么是 std::array？

std::array 是 C++11 引入的，位于 <array> 头文件中。它是一个轻量级的、基于栈的容器，旨在提供 C 数组的性能和内存布局，同时增加 C++ 容器的安全性和便利性。

#include <array>

// 声明一个包含5个int类型元素的std::array
std::array<int, 5> cpp_arr;

std::array 的主要特点包括：

• 固定大小：与 C 数组一样，大小在编译时确定。
• 内存布局：元素在内存中连续存储，与 C 数组完全相同。
• 访问方式：提供 [] 和 at() 两种访问方式。
• 边界检查：at() 方法提供边界检查，越界访问会抛出 std::out_of_range 异常。
• 类型安全：数组的大小是其类型的一部分。std::array<int, 5> 和 std::array<int, 10> 是完全不同的类型。
• 丰富的接口：提供了许多有用的成员函数，如 .size()、.empty()、.fill() 等。
• 标准库兼容性：支持迭代器，可以无缝地与标准库算法（如 std::sort、std::for_each）一起使用。

核心区别对比

下表清晰地总结了 C 数组和 std::array 之间的主要区别。

为什么推荐使用 std::array？

在 C++ 中，当需要一个固定大小的数组时，std::array 几乎总是比原始的 C 数组更好的选择。以下是几个关键原因：

1. 更高的安全性：边界检查

C 数组的最大隐患之一是缺乏边界检查。错误的下标可能导致内存损坏，这种错误往往难以调试。

#include <iostream>

int main() {
    int c_arr[5] = {1, 2, 3, 4, 5};

    // 越界写入，这是未定义行为，可能导致程序崩溃或数据损坏
    c_arr[10] = 99; 

    // 越界读取，也是未定义行为
    std::cout << c_arr[10] << std::endl; 

    return 0;
}

而 std::array 提供了安全的 at() 方法。当尝试访问越界元素时，它会抛出一个明确的异常，使问题更容易被发现和修复。

#include <iostream>
#include <array>
#include <stdexcept>

int main() {
    std::array<int, 5> cpp_arr = {1, 2, 3, 4, 5};

    try {
        // 尝试越界写入，会抛出 std::out_of_range 异常
        cpp_arr.at(10) = 99; 
    } catch (const std::out_of_range& e) {
        std::cerr << "错误: " << e.what() << std::endl;
    }

    try {
        // 尝试越界读取，同样会抛出异常
        std::cout << cpp_arr.at(10) << std::endl; 
    } catch (const std::out_of_range& e) {
        std::cerr << "错误: " << e.what() << std::endl;
    }

    return 0;
}

2. 更多的便利方法

std::array 提供了一系列方便的成员函数，使代码更简洁、更易读。

• 获取大小：使用 .size() 而不是手动计算。
• 检查是否为空：使用 .empty()。
• 填充所有元素：使用 .fill(value)。
• 交换内容：使用 .swap(other_array)。

#include <iostream>
#include <array>

int main() {
    std::array<int, 5> arr;

    // 使用 .fill() 填充所有元素为 0
    arr.fill(0); 

    // 使用 .size() 获取大小
    std::cout << "数组大小: " << arr.size() << std::endl; 

    // 使用基于范围的 for 循环遍历
    for (int num : arr) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

3. 与标准库算法无缝集成

C 数组不能直接与标准库算法（如 std::sort、std::find）一起使用，因为算法需要迭代器。而 std::array 提供了迭代器，可以像使用 std::vector 一样使用它们。

#include <iostream>
#include <array>
#include <algorithm> // 包含 std::sort

int main() {
    std::array<int, 5> arr = {5, 3, 1, 4, 2};

    // 使用 std::sort 对数组进行排序
    std::sort(arr.begin(), arr.end()); 

    // 使用 std::for_each 和 lambda 表达式打印元素
    std::for_each(arr.begin(), arr.end(), [](int num) {
        std::cout << num << " ";
    });
    std::cout << std::endl;

    return 0;
}

4. 类型安全

由于 std::array 的大小是其类型的一部分，编译器可以在编译时进行更严格的类型检查。这可以防止将一个大小不匹配的数组传递给一个期望特定大小的函数，从而避免潜在的逻辑错误。

#include <array>

void process_small_array(std::array<int, 3> data) {
    // ... 处理 3 个元素的数组
}

int main() {
    std::array<int, 3> small_arr = {1, 2, 3};
    std::array<int, 5> large_arr = {1, 2, 3, 4, 5};

    // 正确：类型匹配
    process_small_array(small_arr); 

    // 错误：类型不匹配，编译器会报错
    // process_small_array(large_arr); 

    return 0;
}

如何使用 std::array

1. 包含头文件

在你的源文件顶部添加 #include <array>。

2. 声明

使用 std::array<数据类型, 大小> 变量名; 的语法声明。

#include <array>

int main() {
    // 声明一个包含 10 个 double 类型元素的 std::array
    std::array<double, 10> my_array;

    return 0;
}

3. 初始化

std::array 支持多种初始化方式。

• 默认初始化：元素被值初始化（对于基本类型，通常是 0）。

  std::array<int, 3> arr1; // arr1 的元素是 {0, 0, 0}

• 列表初始化：使用花括号列表初始化。

  std::array<int, 3> arr2 = {10, 20, 30};
  std::array<int, 3> arr3{10, 20, 30}; // C++11 及以后推荐的方式

• 聚合初始化：C++17 及以后支持。

  std::array<int, 3> arr4 = {1, 2, 3};

4. 访问元素

• 使用 []：与 C 数组相同，不进行边界检查。

  arr2[0] = 100; // 安全的，因为 0 在范围内

• 使用 at()：进行边界检查，越界时抛出异常。

  arr2.at(1) = 200; // 安全的
  // arr2.at(5) = 500; // 会抛出 std::out_of_range 异常

5. 获取大小和容量

• .size()：返回元素的数量。

  std::cout << "元素数量: " << arr2.size() << std::endl; // 输出 3

• .max_size()：返回数组可以容纳的最大元素数量，对于 std::array 来说，它总是等于 .size()。

  std::cout << "最大容量: " << arr2.max_size() << std::endl; // 输出 3

• .empty()：如果大小为 0，则返回 true。

  std::array<int, 0> empty_arr;
  std::cout << "是否为空: " << (empty_arr.empty() ? "是" : "否") << std::endl; // 输出 是

6. 修改和操作

• .fill(value)：用指定的值填充所有元素。

  arr2.fill(99); // arr2 现在是 {99, 99, 99}

• .swap(other)：交换两个 std::array 的内容。

  std::array<int, 3> arr_a = {1, 2, 3};
  std::array<int, 3> arr_b = {4, 5, 6};
  arr_a.swap(arr_b); // arr_a 现在是 {4, 5, 6}, arr_b 现在是 {1, 2, 3}

• 迭代：使用基于范围的 for 循环或迭代器。

  for (int num : arr_a) {
      std::cout << num << " ";
  }
  // 或者
  for (auto it = arr_a.begin(); it != arr_a.end(); ++it) {
      std::cout << *it << " ";
  }

在大多数现代 C++ 代码中，当需要一个固定大小的数组时，std::array 是比原始 C 数组更好的选择，因为它提供了更好的安全性、便利性和类型安全，而不会带来任何运行时开销。