如何使用C++20的`std::span`提升容器访问性能？

作者

std::span是C++20新增的轻量级视图（view），它不拥有底层数据，而是仅仅保存指向数据的指针与长度信息。与传统的指针或引用相比，std::span提供了更安全、更易读的接口，并能显著简化函数签名、提升代码性能。下面通过几个实例，详细阐述如何在实际项目中利用std::span实现高效、可维护的容器访问。

1. 基础语法与构造

#include <span>
#include <vector>
#include <array>
#include <iostream>

void process(std::span <int> s) {
    for (auto x : s) {
        std::cout << x << ' ';
    }
    std::cout << '\n';
}

int main() {
    std::vector <int> vec{1, 2, 3, 4, 5};
    std::array<int, 4> arr{10, 20, 30, 40};

    process(vec);            // 自动转换为 std::span <int>
    process(arr);            // 同样可以
    process({1, 2, 3, 4});   // 临时数组转为 span
}
  • 构造：`std::span ` 可以从 `T*`、`T[N]`、`std::array`、`std::vector` 等直接构造。
  • 无所有权：span 并不持有底层容器，调用结束后不影响容器生命周期。

2. 子视图与切片

std::vector <int> data{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

std::span <int> whole(data);                 // 整个向量
std::span <int> half = whole.first(5);       // 前 5 个元素
std::span <int> tail = whole.last(5);        // 后 5 个元素
std::span <int> middle = whole.subspan(3, 4); // 从索引 3 开始，长度 4

process(half);   // 0 1 2 3 4
process(tail);   // 5 6 7 8 9
process(middle); // 3 4 5 6
  • first(n) / last(n)：返回前/后 n 个元素的子视图。
  • subspan(offset, size)：返回从 offset 开始，长度为 size 的子视图。
  • 通过切片，可在不复制数据的前提下，安全地操作容器子集。

3. 只读 vs 可写

void read_only(std::span<const int> s) { ... }   // 只读视图
void writable(std::span <int> s) { ... }          // 可写视图
  • const 修饰的 std::span 表示只读访问；可避免不必要的修改。
  • 在需要遍历但不修改容器的场景下使用 const 可提升安全性。

4. 与变长参数和模板的结合

template<typename... Args>
std::array<int, sizeof...(Args)> to_array(Args... args) {
    return {args...};
}

void sum(std::span<const int> s) {
    int total = 0;
    for (int x : s) total += x;
    std::cout << "sum = " << total << '\n';
}

int main() {
    auto arr = to_array(5, 10, 15);
    sum(arr); // 30
}
  • std::span 可以与 std::array 或 std::vector 无缝配合，使得模板函数更灵活。
  • 通过 std::span，不需要额外声明长度模板参数，代码更简洁。

5. 性能优势

5.1 消除拷贝

传统函数：

void process(std::vector <int> v); // 复制整个向量

使用 span：

void process(std::span <int> s);   // 仅传递指针和长度
  • 复制成本从 O(n) 降为 O(1)。
  • 对大容器（如百万级元素）尤其重要。

5.2 与 std::array 一同使用

void sort_inplace(std::span <int> s) {
    std::sort(s.begin(), s.end());
}
  • 可对任意可连续存储的容器进行原地排序，代码统一。

6. 常见陷阱与注意事项

  1. 生命周期管理
    span 仅引用数据，使用时一定要保证底层容器不被销毁或重新分配。 

    std::vector <int> v = [create_vector]();
auto sp = std::span(v);
v.clear(); // sp 现在悬空

  2. 非连续存储
    std::span 只能用于连续存储的数据结构（如数组、std::vector、std::array）。
    不能直接使用 std::list 或链表。

  3. 对齐和对齐
    对于 POD 类型，span 与裸指针的对齐一致。但若使用非 POD，需注意对齐问题。

  4. 编译器支持
    C++20 标准库必须开启 -std=c++20。
    对于旧编译器，可使用 GSL（Guideline Support Library）的 gsl::span 替代。

7. 进阶：std::span 与 SIMD

在使用 SIMD 指令（如 AVX/AVX-512）时，std::span 可以帮助保证数据连续性：

#include <immintrin.h>

void vector_add(std::span <float> a, std::span<float> b, std::span<float> out) {
    assert(a.size() == b.size() && a.size() == out.size());
    size_t i = 0;
    for (; i + 8 <= a.size(); i += 8) {
        __m256 va = _mm256_loadu_ps(&a[i]);      // 加载
        __m256 vb = _mm256_loadu_ps(&b[i]);
        __m256 vres = _mm256_add_ps(va, vb);     // SIMD 加法
        _mm256_storeu_ps(&out[i], vres);         // 存储
    }
    // 处理剩余元素
    for (; i < a.size(); ++i) out[i] = a[i] + b[i];
}
  • std::span 保证了指针合法性，编译器可自动生成高效指令。
  • 与裸指针相比，使用 span 能避免错误的指针运算。

8. 结语

std::span 通过提供一个轻量级、无所有权的容器视图，极大简化了函数签名、提升了代码安全性，并在性能方面带来了显著优势。无论是对传统容器的切片、只读访问，还是与 SIMD、模板结合使用，std::span 都能让 C++ 开发者写出更简洁、更高效的代码。随着 C++20 的普及，建议在项目中尽量替换裸指针或 std::initializer_list 为 std::span，并注意生命周期管理，以充分发挥其优势。

发表评论