std::span ​

什么是 std::span ​

std::span 是 C++20 引入的轻量级、非拥有的连续内存视图。它类似于 std::string_view 对字符串的作用,但适用于任意类型的连续序列。span 本质上就是一个指针加长度,可以统一地引用 C 数组、std::array、std::vector 等任何连续内存容器。

cpp
#include <span>
// span 内部大致等价于:
// struct { T* ptr; size_t length; };

std::span 的两种模式 ​

模式声明大小说明
动态范围std::span<int>运行时确定类似指针+长度
静态范围std::span<int, 5>编译期固定为 5编译器可以做更多优化

基本示例 ​

cpp
#include <iostream>
#include <span>
#include <vector>
#include <array>
#include <algorithm>
#include <numeric>

// ============================
// 示例1:基本创建方式
// ============================

void creation_demo() {
    // 从 C 数组创建
    int c_arr[] = {1, 2, 3, 4, 5};
    std::span<int> s1{c_arr};

    // 从 std::array 创建
    std::array<int, 4> std_arr = {10, 20, 30, 40};
    std::span<int> s2{std_arr};

    // 从 std::vector 创建
    std::vector<int> vec = {100, 200, 300};
    std::span<int> s3{vec};

    // 从指针+长度创建
    std::span<int> s4{c_arr, 3};  // 前 3 个元素

    // 从迭代器对创建
    std::span<int> s5{vec.begin(), vec.end()};

    // CTAD(类模板参数推导)
    std::span s6{c_arr};       // 推导为 span<int, 5>(静态范围)
    std::span s7{vec};          // 推导为 span<int>(动态范围)

    std::cout << "c_arr span 大小: " << s1.size() << std::endl;
    std::cout << "vector span 大小: " << s3.size() << std::endl;
}

// ============================
// 示例2:span 作为函数参数
// ============================

// 一个函数同时接受 vector、array、C 数组
void print_elements(std::span<const int> data) {
    for (int v : data) {
        std::cout << v << " ";
    }
    std::cout << std::endl;
}

void param_demo() {
    int c_arr[] = {1, 2, 3};
    std::array<int, 4> std_arr = {4, 5, 6, 7};
    std::vector<int> vec = {8, 9, 10, 11, 12};

    // 同一个函数,不同容器类型
    std::cout << "C 数组: ";
    print_elements(c_arr);

    std::cout << "std::array: ";
    print_elements(std_arr);

    std::cout << "vector: ";
    print_elements(vec);
}

// ============================
// 示例3:只读 vs 可写
// ============================

// 只读访问:span<const int>
int sum(std::span<const int> data) {
    int total = 0;
    for (int v : data) total += v;
    return total;
}

// 可写访问:span<int>
void double_values(std::span<int> data) {
    for (int& v : data) v *= 2;
}

void readwrite_demo() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    std::cout << "求和: " << sum(vec) << std::endl;  // 15

    double_values(vec);
    std::cout << "翻倍后: ";
    print_elements(vec);  // 2 4 6 8 10
}

// ============================
// 示例4:子视图(subspan)
// ============================

void subspan_demo() {
    std::vector<int> data = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    std::span<int> s{data};

    // first(n):取前 n 个元素
    auto first3 = s.first(3);
    std::cout << "前3个: ";
    print_elements(first3);  // 0 1 2

    // last(n):取后 n 个元素
    auto last3 = s.last(3);
    std::cout << "后3个: ";
    print_elements(last3);  // 7 8 9

    // subspan(offset, count):取中间部分
    auto middle = s.subspan(3, 4);
    std::cout << "中间4个: ";
    print_elements(middle);  // 3 4 5 6

    // subspan(offset):从 offset 到末尾
    auto tail = s.subspan(7);
    std::cout << "从第7个起: ";
    print_elements(tail);  // 7 8 9
}

// ============================
// 示例5:静态范围
// ============================

// 静态范围:编译期知道大小
void process_triple(std::span<int, 3> triple) {
    std::cout << "三元组: ";
    for (int v : triple) std::cout << v << " ";
    std::cout << std::endl;
}

void static_extent_demo() {
    int arr[3] = {10, 20, 30};
    process_triple(arr);  // 直接传 C 数组

    std::array<int, 3> std_arr = {40, 50, 60};
    process_triple(std_arr);  // 传 std::array

    // 静态范围可以隐式转换为动态范围
    std::span<int, 3> static_span{arr};
    std::span<int> dynamic_span = static_span;  // 隐式转换
    std::cout << "动态 span 大小: " << dynamic_span.size() << std::endl;
}

// ============================
// 示例6:span 与算法配合
// ============================

void algorithm_demo() {
    std::vector<int> data = {5, 3, 8, 1, 9, 2, 7};
    std::span<int> s{data};

    // 排序
    std::ranges::sort(s);
    std::cout << "排序后: ";
    print_elements(s);

    // 查找
    auto it = std::ranges::find(s, 7);
    if (it != s.end()) {
        std::cout << "找到 7, 位置: " << std::distance(s.begin(), it) << std::endl;
    }

    // 反转
    std::ranges::reverse(s);
    std::cout << "反转后: ";
    print_elements(s);
}

// ============================
// 示例7:as_bytes 和 as_writable_bytes
// ============================

void bytes_demo() {
    int data[] = {0x01020304, 0x05060708};
    std::span<int> s{data};

    // 将 span<int> 转为 span<const std::byte>
    auto bytes = std::as_bytes(s);
    std::cout << "字节数: " << bytes.size() << std::endl;  // 8(2个int,每个4字节)

    std::cout << "原始字节: ";
    for (auto b : bytes) {
        std::cout << std::to_integer<int>(b) << " ";
    }
    std::cout << std::endl;
}

// ============================
// 示例8:span 的成员函数
// ============================

void member_demo() {
    std::vector<int> data = {10, 20, 30, 40, 50};
    std::span<int> s{data};

    // 基本属性
    std::cout << "size: " << s.size() << std::endl;
    std::cout << "size_bytes: " << s.size_bytes() << std::endl;
    std::cout << "empty: " << std::boolalpha << s.empty() << std::endl;

    // 元素访问
    std::cout << "front: " << s.front() << std::endl;
    std::cout << "back: " << s.back() << std::endl;
    std::cout << "s[2]: " << s[2] << std::endl;

    // 底层数据指针
    int* ptr = s.data();
    std::cout << "data(): " << *ptr << std::endl;
}

int main() {
    std::cout << "=== 创建 ===" << std::endl;
    creation_demo();

    std::cout << "\n=== 函数参数 ===" << std::endl;
    param_demo();

    std::cout << "\n=== 读写 ===" << std::endl;
    readwrite_demo();

    std::cout << "\n=== 子视图 ===" << std::endl;
    subspan_demo();

    std::cout << "\n=== 静态范围 ===" << std::endl;
    static_extent_demo();

    std::cout << "\n=== 算法 ===" << std::endl;
    algorithm_demo();

    std::cout << "\n=== 字节视图 ===" << std::endl;
    bytes_demo();

    std::cout << "\n=== 成员函数 ===" << std::endl;
    member_demo();

    return 0;
}

span 的成员函数一览 ​

函数说明
size()元素个数
size_bytes()字节总大小
empty()是否为空
front()第一个元素
back()最后一个元素
operator[]下标访问(无边界检查)
data()底层指针
begin() / end()迭代器
rbegin() / rend()反向迭代器
first(n)前 n 个元素的子 span
last(n)后 n 个元素的子 span
subspan(offset, count)从 offset 开始的 count 个元素

span vs string_view 对比 ​

特性std::span<T>std::string_view
适用类型任意类型 T仅字符类型
可写span<T> 可写,span<const T> 只读始终只读
连续性要求连续内存连续内存
空终止符不关心不要求(但底层可能有)
典型用途通用数组视图字符串视图

适用场景 ​

  • 函数参数统一接受不同容器类型(vector、array、C 数组)
  • 替代指针+长度的传统 C 接口
  • 对连续内存进行切片操作
  • 与 C API 交互(传递 data() 和 size())
  • 需要零开销的非拥有引用

常见问题 ​

span 是容器还是视图?

span 是视图,不拥有数据。它是对已有连续内存的一个轻量级引用,大小等于一个指针加一个 size_t。

span 可以用于 list 或 map 吗?

不可以。span 要求底层数据是连续存储的(contiguous),list 和 map 不满足这个要求。

span 有边界检查吗?

operator[] 没有边界检查。C++26 将添加 at() 方法提供边界检查。

span 可以返回吗?

可以,但必须确保底层数据的生命周期长于 span。返回指向局部变量的 span 会导致悬空引用。

注意事项 ​

  • span 不拥有数据——底层数据的生命周期必须长于 span
  • span<T> 允许修改元素,span<const T> 只读
  • span 应该按值传递(它本身就很小)
  • 静态范围(span<T, N>)可以隐式转为动态范围(span<T>),反过来不行
  • operator[] 没有边界检查
  • 不要返回指向临时对象的 span

总结 ​

std::span 是 C++20 引入的通用连续内存视图,类似于 string_view 的泛化版本。它让函数可以用统一的参数类型接受 C 数组、std::array、std::vector 等任何连续容器,消除了指针+长度的老式接口。span 有静态范围和动态范围两种模式,提供了 first、last、subspan 等切片操作。作为非拥有的视图,使用时必须注意底层数据的生命周期。span 按值传递,开销极小。