近日，在 Stack Overflow 及多个开发者社区中，一个问题引发了广泛讨论：“How to iterate over two objects without heap allocations?”（如何在不进行堆分配的情况下迭代两个对象？）。该问题看似简单，实则触及了高性能编程、嵌入式开发及游戏引擎等场景中的核心痛点——堆分配带来的不可预测延迟与内存碎片。本文将围绕该问题，结合 C++、Rust 等主流语言的最新实践，为读者梳理几种行之有效的零堆分配并行迭代方案。

问题背景：为什么拒绝堆分配？

在实时系统、物联网设备或帧率敏感的渲染管线中，每一次 malloc 或 new 都可能引入微秒级的开销，并可能导致缓存未命中。传统的 std::vector、std::list 等动态容器，虽能方便地存储任意数量的元素，但其内部通常依赖堆分配。当开发者需要同时遍历两个长度相等或相关的对象（如两张纹理的像素、两帧骨骼动画数据）时，若使用堆分配的“中间容器”（如拼接后的 std::vector<std::pair>），则会破坏性能确定性。

方案一：经典原位索引循环（零额外开销）

最直接的方法是用索引访问两个数组。无论对象是 C 风格数组、std::array 还是栈上分配的静态数组，只需一个 for 循环即可避免任何堆分配：

// 假设两个栈数组长度相同
int a[1024] = {...};
int b[1024] = {...};
for (size_t i = 0; i < 1024; ++i) {
    process(a[i], b[i]);
}

此方案在 C 和 C++ 中普遍适用，编译器常能将其优化为 SIMD 指令。缺点是需要显式管理索引，且在迭代器模式的泛型代码中不够优雅。

方案二：利用 C++17 结构化绑定与迭代器适配（栈上“拉链”）

C++17 引入的结构化绑定，配合 std::array 的迭代器，可以写出更现代的代码，同时仍保证栈分配：

std::array<int, 1024> a;
std::array<int, 1024> b;
auto ia = a.begin();
auto ib = b.begin();
for (; ia != a.end(); ++ia, ++ib) {
    auto& [ref_a, ref_b] = *ia; // 但注意这里需要将两个迭代器解包
}

然而，更直接的方案是采用 C++20 的 std::views::zip 视图。该视图不会复制元素，而是生成一个惰性组合的迭代器，所有元数据均在栈上：

#include <ranges>
for (auto [x, y] : std::views::zip(a, b)) {
    process(x, y);
}

关键点：zip 视图本身不分配堆内存，它只是保存两个原始迭代器的引用。编译器可以将其优化为与手写索引循环相同的机器码。在目前主流的 GCC 和 Clang 中，std::views::zip 已被支持并鼓励使用。

方案三：Rust 语言的原生迭代器组合

Rust 在设计上就强调栈分配优先，其标准库的 Iterator::zip 方法天然不支持堆分配。对于两个栈数组（如 [u8; 1024]），开发者可直接调用 iter() 或 iter_mut() 获得迭代器，再 zip 起来：

let a: [u8; 1024] = [0; 1024];
let b: [u8; 1024] = [0; 1024];
for (x, y) in a.iter().zip(b.iter()) {
    process(x, y);
}

Rust 的 zip 返回一个 std::iter::Zip 结构体，它仅存储两个轻量级迭代器，所有内存均在栈上。Rust 的所有权机制还保证了这两个数组不会被意外移动或释放，从而避免了堆分配的必要。

方案四：当对象类型不同时——使用 std::variant 或枚举变体

问题中的“对象”可能并非数组，而是两个不同类型的实例（例如一个 std::string 和一个 std::vector<int>）。要想同时迭代二者而不堆分配，一种思路是将它们抽象为同一类型的变体，但变体本身的大小是固定的（栈可容纳）。例如：

struct StringIter {
    std::string_view sv;
    size_t pos = 0;
};
 struct VectorIter {
    std::span<int> s;
    size_t pos = 0;
};
using IterVariant = std::variant<StringIter, VectorIter>;

然后通过 std::visit 实现迭代。此方法虽无堆分配，但增加了运行时开销。在需要极致性能的场景下，更推荐使用模板函数分别处理不同类型。

专家建议：选型权衡

  • 固定长度、类型相同：优先使用 std::views::zip 或 Rust 的 zip。可读性高，性能无损。
  • 长度动态但已知最大值：可采用 std::array 声明最大大小，再用起始索引和长度控制循环。栈上分配固定缓冲区，避免堆分配。
  • 需要泛型支持：C++20 的 Ranges 库或 Rust 的迭代器适配器最为灵活。
  • 极端嵌入式环境（无标准库）：手写索引循环+ volatile 屏障确保优化。

结语

“如何在不进行堆分配的情况下迭代两个对象”这一问题，实则是现代软件工程中“零成本抽象”理念的缩影。无论是 C++ 的 Ranges 库、Rust 的迭代器组合，还是最基础的索引循环，都能帮助开发者在保证性能的同时编写清晰代码。随着编译器优化水平的提升，开发者越来越不需要牺牲可读性来换取栈上内存的安全性。下一次当你面对类似需求时，请记住：可选方案丰富，堆分配并非必然。