**如何在 C++20 中使用 std::span 进行安全的数组操作**

在 C++20 之前，我们通常使用指针和长度来传递数组或缓冲区给函数，或者使用 std::vector、std::array 等容器。但这些方式各有局限：指针会导致悬空指针风险；std::vector 需要动态内存分配；std::array 固定大小。C++20 引入了 std::span，它提供了一种轻量、无所有权、视图化的方式来处理连续内存块。下面我们从概念、实现细节、使用场景和性能优势等方面展开讨论。

1. `std::span` 的核心概念

无所有权：std::span 仅保存指针和长度，不负责内存管理。它不复制元素，也不改变底层容器的生命周期。
轻量封装：它本质上是一个 T* 指针加一个 size_t 长度，编译器可以进行内联优化，几乎没有运行时成本。
类型安全：`std::span ` 对元素类型 `T` 具有强类型约束，编译期即可发现不匹配的类型。
兼容多种容器：可直接从数组、std::vector、std::array、std::string、std::basic_string 等构造。

2. 基本用法

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

void process(std::span <int> data) {
    for (auto& val : data) {
        val *= 2;                     // 就地修改
    }
}

int main() {
    std::vector <int> vec = {1, 2, 3, 4, 5};
    process(vec);                    // 直接传递 std::vector

    std::array<int, 3> arr = {{10, 20, 30}};
    process(arr);                    // 直接传递 std::array

    int raw[4] = {7, 8, 9, 10};
    process(std::span <int>(raw, 4)); // 或者使用原始数组
}

注意：在 process 函数中，std::span 只提供了访问权，不拥有底层数据；若底层容器销毁，传递给 process 的 span 将成为悬空指针。

3. 受限视图：`std::span<const T>`

如果不想修改底层数据，可以使用 const 视图：

void printSum(std::span<const int> data) {
    int sum = 0;
    for (int val : data) sum += val;
    std::cout << "Sum = " << sum << '\n';
}

通过 const 限制，printSum 只能读取，编译器会保证不对元素进行修改。

4. 子视图：`subspan`

可以在已有 span 上进一步切片，得到子视图：

std::span <int> whole = {vec.data(), vec.size()};
auto firstHalf = whole.subspan(0, whole.size() / 2);
auto lastHalf  = whole.subspan(whole.size() / 2);

subspan(offset, length)：从 offset 开始截取 length 个元素。
subspan(offset)：从 offset 到尾部。

5. `std::span` 与 C 风格接口的桥梁

很多系统库仍使用 C 风格数组接口，例如：

void c_api(int* arr, size_t n);

在 C++20 中可以直接把 std::span 传给它：

c_api(vec.data(), vec.size());          // 传统方式
c_api(vec.data(), std::size(vec));      // 或者使用 std::size

如果你想把 std::span 直接作为参数，你可以提供一个包装：

void wrapper(std::span <int> sp) {
    c_api(sp.data(), sp.size());        // 自动展开
}

6. 性能与安全性

零成本抽象：std::span 只是指针+长度，编译器可直接内联使用，无额外指针间接。
避免深拷贝：与 std::vector 的拷贝相比，std::span 完全不涉及数据拷贝。
边界安全：虽然 std::span 本身不做边界检查，但在 STL 容器迭代器中使用时会保持与容器相同的安全性。若需要额外检查，可使用 std::span::subspan 时的 checked_subspan（C++23）或自定义断言。
线程安全：由于 std::span 本身不维护状态，只是视图，线程安全性取决于底层容器。若在多线程环境下修改同一段数据，需要自行同步。

7. 进阶用法：`std::span` 与 `std::span_view`（C++23）

C++23 引入了 std::span_view，它在 std::span 的基础上实现了 非所有权、可变长 的视图。std::span_view 的构造更为灵活，支持 std::initializer_list、std::basic_string_view 等。

#include <span_view>
#include <string_view>

void analyze(std::span_view <int> sv) {
    // ...
}

8. 常见错误与调试技巧

悬空指针

std::span <int> sp(vec.data(), vec.size());
vec.clear();          // vec 变为空，sp悬空

解决：确保 span 的生命周期不超过底层容器。

未对齐访问
std::span 可以传递任何连续内存，但如果底层数据不是对齐的，某些 SIMD 操作可能失效。需要手动检查对齐。
非连续内存
`std::vector
`、`std::string` 的 `operator[]` 返回引用而非实际地址，不能用作 `std::span`。使用 `std::string_view` 或 `std::vector::data()` 不是安全的。

9. 小结

std::span 为 C++20 引入的一种无所有权、轻量级的数组/缓冲区视图。
它兼容多种容器，提供安全、可读、可写的接口。
与传统指针相比，std::span 提升了类型安全与语义清晰度。
在性能方面，几乎无额外成本，避免了不必要的数据复制。
通过 subspan 等函数，能够方便地创建子视图，支持复杂数据切片需求。

使用 std::span 可以让 C++ 代码更简洁、可维护，并且在跨库或与 C 接口交互时提供更安全的抽象。希望本文能帮助你在日常项目中更好地运用这项新特性。

1. std::span 的核心概念

2. 基本用法

3. 受限视图：std::span<const T>

4. 子视图：subspan

5. std::span 与 C 风格接口的桥梁