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 按值传递,开销极小。