std::array 详解：静态数组的封装

说实话，C++ 程序员跟数组打交道那是家常便饭。但 C 风格数组有多坑，我相信老手都深有体会。我自己刚入行那会儿，就因为数组越界查了一整天的 bug——那种感觉，嗯，不想再体验第二次。

好在 C++11 给我们带来了 std::array。它本质上就是个静态数组，但披上了 STL 容器的外衣。说白了，它既有 C 数组的性能，又有 STL 容器的安全性和便利性。

std::array 是什么？

std::array 定义在 <array> 头文件中。它是一个固定大小的容器，大小在编译期就确定了。跟 C 风格数组一样，它分配在栈上，没有额外的内存开销。

来看个最简单的例子：

#include <array>
#include <iostream>

int main() {
    std::array<int, 5> arr = {1, 2, 3, 4, 5};
    
    // 访问元素
    std::cout << arr[0] << std::endl;      // 不检查越界
    std::cout << arr.at(0) << std::endl;   // 检查越界，抛异常
    
    // 获取大小
    std::cout << "Size: " << arr.size() << std::endl;
    
    return 0;
}

你看，std::array<int, 5> 的模板参数有两个：元素类型和数组大小。大小是编译期常量，不能运行时改变。

与 C 风格数组的对比

我经常在团队里说：能用 std::array 就别用 C 数组。为什么？咱们来掰扯掰扯。

特性	C 风格数组	std::array
内存分配	栈上	栈上
大小获取	sizeof(arr)/sizeof(arr[0])	arr.size()
越界检查	无	at() 提供检查
赋值操作	不支持	支持 arr1 = arr2
作为函数参数	退化为指针	保持数组信息
迭代器支持	无	完整 STL 迭代器
性能	极高	与 C 数组相同

这里我要特别强调一点：性能上两者完全一致。因为 std::array 的成员函数基本都是内联的，编译器优化后生成的机器码跟 C 数组一模一样。所以别担心性能问题。

std::array 的核心操作

咱们来看看 std::array 到底能干什么。我个人觉得，最常用的操作就这么几个：

1. 访问元素

std::array<int, 4> arr = {10, 20, 30, 40};

// operator[] - 不检查越界
int a = arr[2];  // 30

// at() - 检查越界，越界抛 std::out_of_range
int b = arr.at(2);  // 30

// front() / back() - 首尾元素
int first = arr.front();  // 10
int last = arr.back();    // 40

// data() - 获取底层 C 数组指针
int* raw_ptr = arr.data();  // 等价于 &arr[0]

这里有个小坑：operator[] 不检查越界，跟 C 数组一样。我建议在调试阶段多用 at()，发布版本再换成 operator[] 提升性能。

2. 迭代器支持

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

// 范围 for 循环
for (int x : arr) {
    std::cout << x << " ";
}

// 使用迭代器
for (auto it = arr.begin(); it != arr.end(); ++it) {
    std::cout << *it << " ";
}

// 反向迭代
for (auto rit = arr.rbegin(); rit != arr.rend(); ++rit) {
    std::cout << *rit << " ";
}

你想想看，C 数组能做到这些吗？不能。这就是 std::array 的优势——它跟所有 STL 算法无缝配合。

3. 填充与交换

std::array<int, 5> arr1, arr2;

arr1.fill(42);  // 全部填充为 42
// arr1 = {42, 42, 42, 42, 42}

arr2 = {1, 2, 3, 4, 5};
arr1.swap(arr2);  // 交换两个数组的内容
// arr1 = {1, 2, 3, 4, 5}
// arr2 = {42, 42, 42, 42, 42}

fill() 这个函数特别实用。我记得有一次需要初始化一个固定大小的缓冲区，用 C 数组得写个循环，用 std::array 一行搞定。

使用场景分析

说了这么多，到底什么时候该用 std::array？我总结了几种典型场景：

场景一：固定大小的缓冲区

比如网络协议中的报文头、固定大小的配置表、颜色 RGB 值等。这些数据大小在编译期就确定了，用 std::array 最合适。

// RGB 颜色表示
using Color = std::array<uint8_t, 3>;

Color red = {255, 0, 0};
Color green = {0, 255, 0};

// 网络报文头
struct PacketHeader {
    std::array<char, 4> magic;     // 魔数
    std::array<uint8_t, 6> mac;    // MAC 地址
    uint32_t length;
    uint32_t checksum;
};

场景二：需要 STL 算法支持的静态数组

如果你想对静态数组进行排序、查找、遍历等操作，std::array 可以直接用 STL 算法：

std::array<int, 6> scores = {88, 92, 75, 63, 99, 81};

// 排序
std::sort(scores.begin(), scores.end());

// 查找
auto it = std::find(scores.begin(), scores.end(), 92);

// 统计
int count = std::count_if(scores.begin(), scores.end(),
                          [](int s) { return s >= 90; });

C 数组想用 std::sort？也不是不行，但得传指针和大小，容易出错。用 std::array 就清爽多了。

场景三：替代 C 风格的多维数组

// 3x4 的矩阵
std::array<std::array<int, 4>, 3> matrix = {{
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
}};

// 访问元素
int val = matrix[1][2];  // 7

// 遍历
for (const auto& row : matrix) {
    for (int elem : row) {
        std::cout << elem << " ";
    }
    std::cout << "\n";
}

避坑指南

知识体系总览

下面这张图帮你理清 std::array 的核心知识点：

总结

std::array 是 C++ 中静态数组的现代解决方案。它保留了 C 数组的性能优势，同时提供了类型安全、越界检查和 STL 兼容性。我个人在项目中几乎不用 C 风格数组了，除非是跟 C 代码交互。

记住一句话：能用 std::array 就别用 C 数组。它不会让你多花一分性能，但能帮你省下不少调试时间。