Skip to main content

Chapter 11: Array

核心问题与阅读主线

本章导读5 个核心小节 · 附自检与总结

std::array<T, N> 将编译期固定数量的内嵌连续存储封装为标准容器,在保持 aggregate 语义与零额外堆分配的同时接入 iterator、STL 算法、tuple interface 与 constexpr 体系。工程上核心要解决的是:何时用 std::array 替代易退化的 C 数组或引入动态分配的 std::vector,以及如何规避默认初始化不定值、线性 swap 与零长访问越界。

全章共用场景样本

贯穿材料贯穿场景

贯穿本章的材料是固定协议头(magic 字节数由协议格式决定)与固定卷积权重(权重数由算法形状决定):两者均要求容量在编译期确定、元素内嵌于宿主对象、整体可复制并可通过 begin() / end() 接入标准算法。

依据 C++ working draft 的 array overview,<array> 中的 std::array<T, N> 是存储 N 个 T 的 contiguous container 与 aggregate,满足 size() == N 不变量,支持随机访问与连续迭代器及至多 N 个可转换元素的列表初始化;代价是容量固定且赋值、swap 按元素执行。

11.1 std::array 的固定大小对象模型​

std::array<T, N> 直接将 N 个 T 作为自身成员保存,建立两项核心约束:

  • 容量即类型:N 是非类型模板实参,std::array<int, 4> 与 std::array<int, 8> 是两个不同类型,函数重载、模板匹配与结构体布局均能感知该差异。
  • 内嵌存储(无独立堆分配):不同于 std::vector<T> 仅保存控制指针/大小/容量并将元素置于动态分配区,std::array<T, N> 的元素位置由宿主对象决定——局部变量在栈上,成员嵌入外层对象,仅当外层对象被动态创建时元素才位于堆上。

以协议头为例,magic 的 4 个 std::byte 直接嵌入 PacketHeader,随宿主整体构造、逐元素拷贝与析构,全程无 allocator 介入:

#include <array>
#include <cstddef>
#include <cstdint>

struct PacketHeader {
std::array<std::byte, 4> magic;
std::uint16_t version;
};

PacketHeader header{
.magic = {std::byte{'P'}, std::byte{'K'}, std::byte{'T'}, std::byte{'1'}},
.version = 3,
};

这段布局对应三个可观察事实:

  • magic.size() 返回 4,且该长度已写入类型 std::array<std::byte, 4>。
  • 非空时 magic.data() 与首元素地址一致,[data(), data() + size()) 为连续有效区间。
  • PacketHeader 的对象大小与布局直接包含 4 个 std::byte、version 以及成员间对齐 padding。

std::array 在布局上接近仅含内嵌数组成员的 aggregate(以下为说明对象关系的教学简化模型;真实标准库实现还需处理 N == 0 特化、类型别名、noexcept、constexpr 与 tuple interface):

template<class T, std::size_t N>
struct teaching_array_shape {
T elems[N];

constexpr T* begin() noexcept { return elems; }
constexpr T* end() noexcept { return elems + N; }
constexpr std::size_t size() const noexcept { return N; }
constexpr T* data() noexcept { return elems; }
};

边界与误区

注意

标准允许 std::array<T, 0> 作为泛型与模板边界值,此时 begin() == end() 且 empty() 为 true;但 data() 的返回值未指定,且 front()、back() 没有有效元素可引用,读取首尾元素前必须先用 empty() 或 size() 确认非空。

11.2 aggregate initialization 与 constexpr 支持​

std::array 没有用户提供的构造函数,因此服从 aggregate initialization:花括号中的初始化器按顺序写入内部 N 个元素,未显式给出的尾部元素按值初始化补齐。

#include <array>

std::array<int, 3> weights_a{1, 2, 3}; // {1, 2, 3}
std::array<int, 3> weights_b{1}; // {1, 0, 0}
std::array<int, 3> weights_c{}; // {0, 0, 0}

边界与误区

注意

声明固定大小缓冲区时不要省略 {}(如 std::array<int, 3> weights;):默认初始化会让标量元素保留不确定值,后续直接读取会进入错误路径。

C++17 引入了 std::array 的类模板实参推导(CTAD),但 deduction guide 要求 (std::is_same_v<T, U> && ...) 成立——所有实参类型必须严格一致,不会为混合类型自动合成共同类型:

#include <array>
#include <type_traits>

std::array values{1, 2, 3};
static_assert(std::is_same_v<decltype(values), std::array<int, 3>>);

// std::array mixed{1, 2u}; // C++17 CTAD 下类型不一致,程序不合格

由于 N 在编译期已知、size() 与大量成员函数带有 constexpr,且 iterator / const_iterator 满足 constexpr iterator 要求,std::array 可直接承载编译期固定权重、查表常量与小型状态转移表:

#include <array>

constexpr std::array<int, 4> coeffs{1, 3, 3, 1};

constexpr int sum_coeffs() {
int sum = 0;
for (int value : coeffs) {
sum += value;
}
return sum;
}

static_assert(sum_coeffs() == 8);

关键事实

std::array<T, N> 能否进入常量求值,既取决于所调 array 成员与算法在目标标准下的 constexpr 支持,也取决于元素类型 T 本身(例如 std::array<std::string, 4> 受限于对应标准版本的 std::string 编译期分配能力与实现支持)。

C++20 的 std::to_array 可从内建数组构造 std::array(左值数组按元素拷贝,右值数组按元素移动)。传入字符串字面量时需注意结尾 '\0' 会被计入长度,协议字段若只需要 3 个可见字符,应显式截取或改用 std::array<char, 3>{'P', 'K', 'T'}:

#include <array>

constexpr auto tag = std::to_array("PKT");
static_assert(tag.size() == 4); // 包含字符串结尾的 '\0'
初始化 / 构造方式适用标准元素结果与工程边界
{1, 2, 3} / {1} / {}C++11+聚合初始化,缺省尾部按 {} 值初始化补零
省略 {}(默认初始化)C++11+标量元素保留不确定值,缓冲区禁止使用
std::array v{1, 2, 3};C++17+ CTAD推导出 std::array<int, 3>;混型实参编译失败
std::to_array(arr)C++20+左值拷贝、右值移动;字符串字面量含 '\0'

11.3 iterator 支持与 STL 集成​

std::array 提供 begin()、end()、cbegin()、cend()、反向迭代器与 data() / size(),其迭代器同时具备随机访问(供 std::sort 等算法使用)与连续迭代能力,可直接作为半开区间 [begin, end) 接入 STL 算法而无需转为 std::vector:

#include <algorithm>
#include <array>
#include <numeric>

int normalize_score(std::array<int, 4> scores) {
std::sort(scores.begin(), scores.end());
return std::accumulate(scores.begin(), scores.end(), 0);
}

接口层只需读写一段连续元素而不接管所有权时,可用非拥有视图 std::span 统一接收 std::array、std::vector 与 C 数组,既避免函数模板按长度 N 膨胀,又让元素生命周期继续由调用方持有:

#include <array>
#include <span>

int checksum(std::span<const std::byte> bytes) {
int sum = 0;
for (std::byte b : bytes) {
sum += static_cast<unsigned char>(b);
}
return sum;
}

void use_header() {
std::array<std::byte, 4> magic{
std::byte{'P'}, std::byte{'K'}, std::byte{'T'}, std::byte{'1'}
};

(void)checksum(magic);
}
维度std::array<T, N>std::span<T>
所有权拥有 N 个元素,绑定宿主生命周期非拥有视图,仅保存指针与长度
长度表达编译期固定并写入类型 N默认动态 extent(也支持静态 extent)
典型职责数据成员、固定存储对象函数形参接口,统一接收连续序列

由于 std::array 没有插入、删除与扩容,元素存储地址在对象生命周期内保持稳定,普通元素赋值、fill 或 swap 均不会使 iterator 失效。array::swap 的语义等价于线性复杂度的 swap_ranges:

#include <array>

void iterator_after_swap() {
std::array<int, 2> left{1, 2};
std::array<int, 2> right{9, 8};

auto it = left.begin();
left.swap(right);

// it 仍指向 left 的第一个元素;该元素的值现在是 9。
*it = 7;
}

边界与误区

注意

iterator 稳定不等于元素值不变:left.swap(right) 后 it 仍指向 left[0] 槽位且可继续解引用,但该位置的值已通过逐元素交换变为 9;同理,赋值与 fill 也会原地改写已有迭代器所指的值。

11.4 与 C 数组、vector 的判别维度​

选择连续序列容器时,应围绕大小来源、所有权、传参保长能力、动态可变性与分配路径做统一对比:

维度C 数组std::array<T, N>std::vector<T>
大小来源声明处的数组边界模板实参 N运行时 size / capacity
类型是否包含大小原始类型含边界,形参常退化类型直接包含 N类型不包含当前 size
元素所有权数组对象拥有元素array 对象拥有元素vector 拥有动态存储中的元素
传参长度裸数组形参退化丢失边界按引用传递保留 N对象自身携带 size
大小变化声明后固定创建后固定可增长、可缩减
标准容器接口零散,需借助 std::begin 等成员接口与 iterator 完整成员接口、容量管理完整
分配路径随所在对象存储随 array 所在对象存储通过 allocator 管理动态存储

三者的具体工程边界如下:

  • C 数组:适合对接 C ABI、硬件寄存器映射或历史底层接口;若接口频繁出现 ptr + len 成对参数,说明调用边界正在手工补偿数组名退化为指针后丢失的长度信息。
  • std::vector:适合元素数量由运行时输入或外部策略决定的场景;代价是多了一层动态存储管理,扩容会移动元素并使 iterator 失效,且需考虑分配、构造、移动与提交点的异常安全。
  • std::array:按引用传递完整类型时不退化,配合非类型模板参数 N 可在编译期保留长度并直接接入 range-for:
#include <array>
#include <cstddef>

template<std::size_t N>
int sum_array(const std::array<int, N>& values) {
int sum = 0;
for (int value : values) {
sum += value;
}
return sum;
}

核心判断

固定长度、元素内嵌宿主且要接入 STL 算法时选 std::array;运行时长度变化时选 std::vector;必须贴合语言级数组边界或 C ABI 时保留 C 数组,并在接口层显式携带长度或转为 std::span。

11.5 工程使用场景​

std::array 适用于将“编译期固定容量”写进类型系统、并统一生命周期与算法接口的场景:

  • 协议字段与固定校验块:固定长度 magic、nonce、hash 片段适合放进 std::array<std::byte, N>,成员拷贝与比较保持对象语义,底层 I/O 可通过 data() 与 size() 对接。
  • 小型数值与图形数据:二维点、RGBA 颜色、3x3 kernel(std::array<float, 9>,函数签名即可限定只接受 9 个系数)及 SIMD 前数据打包;若 kernel 维度转为运行时配置,应改用 std::vector 或专用矩阵类型。
  • 类成员固定子状态:随宿主逐元素拷贝、移动与析构,无容量管理与扩容失败路径,异常安全只取决于元素类型 T 的拷贝、移动、交换与赋值是否抛出。

下面以文件前缀校验为例,用 std::array 持有固定签名、用 std::span 借用外部输入,并以 signature.bytes.size() 作为无猜测循环边界:

#include <array>
#include <cstddef>
#include <span>

struct FileSignature {
std::array<std::byte, 8> bytes;
};

bool has_prefix(std::span<const std::byte> input, const FileSignature& signature) {
if (input.size() < signature.bytes.size()) {
return false;
}

for (std::size_t index = 0; index < signature.bytes.size(); ++index) {
if (input[index] != signature.bytes[index]) {
return false;
}
}
return true;
}

边界与误区

注意

不同于交换内部控制块的 O(1) 容器,std::array 的元素内嵌在对象内部,array::swap 必须逐元素交换,复杂度为 O(N),且异常规格受 T 的 swap 是否抛出影响;高频交换大型固定块时应评估元素交换成本或增加间接层。

排查顺序

  1. 看长度来源:编译期固定事实时纳入 std::array 候选,依赖运行时输入时选 std::vector。
  2. 定所有权:宿主拥有固定元素时用 std::array,函数仅借用连续区间时传 std::span。
  3. 划接口边界:传给 C ABI 时显式传 data() 与 size(),接入 STL 算法时传 iterator 或 range。
  4. 核操作成本:检查 {} 显式初始化、O(N) 逐元素赋值与 swap 开销、元素异常规格及 N == 0 判空前提。

最小自检任务​

动手自检先独立判断

阅读下面代码,判断 header.magic、values、view 和 it 分别体现了 std::array 的哪一条工程规则,并说明 left.swap(right) 后 it 是否还能解引用、它指向哪个对象的元素、该位置的值来自哪里。

#include <array>
#include <cstddef>
#include <span>
#include <type_traits>

struct Header {
std::array<std::byte, 4> magic{};
};

void check() {
Header header{};

std::array values{1, 2, 3};
static_assert(std::is_same_v<decltype(values), std::array<int, 3>>);

std::span<const std::byte> view = header.magic;

std::array<int, 2> left{1, 2};
std::array<int, 2> right{9, 8};
auto it = left.begin();
left.swap(right);

(void)view;
(void)*it;
}

本章知识点总结​

  • 容量即类型与内嵌存储

    std::array<T, N> 将 N 写入类型、size() == N 为不变量,且元素直接内嵌宿主对象而无额外堆分配。

  • 零长特化边界

    std::array<T, 0> 满足 begin() == end(),但 data() 未指定且 front() / back() 无有效元素,访问前须先判空。

  • 聚合初始化与默认值

    保留 aggregate 语义,{} 可对标量补零,而省略 {} 的默认初始化会留下不确定值。

  • CTAD 与 std::to_array

    C++17 CTAD 要求实参类型严格一致;C++20 std::to_array 可转换内建数组,但字符串字面量会带入结尾 '\0'。

  • constexpr 约束

    N、size() 与迭代器支持常量求值,但整段编译期求值仍受元素类型 T 与所调操作能力限制。

  • STL 与 std::span 集成

    提供随机访问与连续迭代器,可直接进 STL 算法或绑定非拥有视图 std::span,避免模板按 N 膨胀。

  • 迭代器稳定与线性 swap

    无扩容使元素地址稳定,但 array::swap 等价于 O(N) 逐元素交换,迭代槽位不变而槽内值会互换。