std::span 边界安全检查
面试考点
std::span 是 C++20 引入的轻量级非拥有视图,用于引用连续内存序列。面试官通过这道题考察你是否理解 span 如何解决 C 数组退化为指针丢失大小信息的问题、静态范围和动态范围的区别、以及 span 的边界检查行为。
核心概念
std::span 内部只有一个指针和一个大小值(动态范围时)或只有一个指针(静态范围时,大小编码在类型中)。它不拥有数据,不管理生命周期。span 的 operator[] 不做边界检查(未定义行为),但提供了带检查的访问方式和子视图操作来提高安全性。
基本示例
#include <iostream>
#include <span>
#include <vector>
#include <array>
#include <algorithm>
#include <numeric>
// ============================
// 示例1:span 解决数组退化问题
// ============================
// 传统 C 风格:数组退化为指针,丢失大小
void print_c_style(int* arr, size_t size) {
for (size_t i = 0; i < size; i++) {
std::cout << arr[i] << " ";
}
std::cout << std::endl;
}
// C++20 span:保留大小信息
void print_span(std::span<const int> data) {
// span 知道自己的大小
std::cout << "size=" << data.size() << ": ";
for (int x : data) {
std::cout << x << " ";
}
std::cout << std::endl;
}
void decay_demo() {
int c_arr[] = {1, 2, 3, 4, 5};
std::vector<int> vec = {10, 20, 30};
std::array<int, 4> arr = {100, 200, 300, 400};
// C 风格需要手动传大小
print_c_style(c_arr, 5);
// span 自动推导大小,接受多种容器类型
print_span(c_arr); // C 数组
print_span(vec); // vector
print_span(arr); // std::array
}
// ============================
// 示例2:静态范围 vs 动态范围
// ============================
void extent_demo() {
int arr[] = {1, 2, 3, 4, 5};
// 动态范围:大小在运行时确定
std::span<int> dynamic_span(arr, 5);
// sizeof(dynamic_span) = sizeof(int*) + sizeof(size_t) = 16 字节
// 静态范围:大小编码在类型中
std::span<int, 5> static_span(arr);
// sizeof(static_span) = sizeof(int*) = 8 字节(大小是类型的一部分)
std::cout << "动态 span 大小: " << sizeof(dynamic_span) << std::endl;
std::cout << "静态 span 大小: " << sizeof(static_span) << std::endl;
// 静态范围可以隐式转换为动态范围
std::span<int> from_static = static_span; // OK
// 动态范围不能隐式转换为静态范围
// std::span<int, 5> from_dynamic = dynamic_span; // 编译错误
// 静态范围的好处:编译器可以做更多优化和检查
// std::span<int, 3> wrong(arr); // 编译错误:arr 有 5 个元素
}
// ============================
// 示例3:边界检查行为
// ============================
void bounds_demo() {
std::vector<int> vec = {10, 20, 30, 40, 50};
std::span<int> s(vec);
// operator[]:不做边界检查(和数组一样)
std::cout << s[0] << std::endl; // 10,OK
std::cout << s[4] << std::endl; // 50,OK
// s[10]; // 越界!未定义行为,不报错
// front() 和 back():不检查是否为空
std::cout << s.front() << std::endl; // 10
std::cout << s.back() << std::endl; // 50
// 安全访问:手动检查
size_t index = 3;
if (index < s.size()) {
std::cout << "安全访问: " << s[index] << std::endl;
}
// empty() 检查
std::span<int> empty_span;
if (empty_span.empty()) {
std::cout << "span 为空" << std::endl;
}
}
// ============================
// 示例4:子视图操作
// ============================
void subview_demo() {
int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
std::span<int> s(arr);
// first(n):前 n 个元素
auto first3 = s.first(3); // {1, 2, 3}
print_span(first3);
// last(n):后 n 个元素
auto last3 = s.last(3); // {8, 9, 10}
print_span(last3);
// subspan(offset, count):从 offset 开始的 count 个元素
auto mid = s.subspan(3, 4); // {4, 5, 6, 7}
print_span(mid);
// 静态范围的子视图:大小在编译期已知
std::span<int, 10> static_s(arr);
auto first5 = static_s.first<5>(); // span<int, 5>
// 编译期就知道大小是 5
// 运行时参数的子视图:返回动态范围
size_t n = 3;
auto first_n = s.first(n); // span<int, dynamic_extent>
// 越界的子视图:未定义行为
// auto bad = s.first(100); // 越界!未定义行为
// auto bad2 = s.subspan(5, 100); // 越界!
// 安全做法:先检查大小
if (s.size() >= 5) {
auto safe = s.first(5);
print_span(safe);
}
}
// ============================
// 示例5:span 不拥有数据
// ============================
void ownership_demo() {
std::span<int> dangling_span;
{
std::vector<int> temp = {1, 2, 3};
dangling_span = temp;
print_span(dangling_span); // OK,temp 还活着
}
// temp 已经析构
// print_span(dangling_span); // 未定义行为!悬空 span
// span 和 string_view 类似:不拥有数据,不延长生命周期
// 使用者必须保证底层数据存活
}
// ============================
// 示例6:span 作为函数参数的最佳实践
// ============================
// 最佳实践:用 span 替代 (pointer, size) 对
// 修改前:
void process_old(int* data, size_t count) {
for (size_t i = 0; i < count; i++) {
data[i] *= 2;
}
}
// 修改后:
void process_new(std::span<int> data) {
for (int& x : data) {
x *= 2;
}
}
// 只读视图
double average(std::span<const double> values) {
if (values.empty()) return 0.0;
double sum = std::accumulate(values.begin(), values.end(), 0.0);
return sum / values.size();
}
void best_practice_demo() {
std::vector<int> vec = {1, 2, 3, 4, 5};
// 旧接口:容易传错大小
process_old(vec.data(), vec.size());
// 新接口:无法传错大小
process_new(vec);
for (int x : vec) std::cout << x << " ";
std::cout << std::endl;
std::vector<double> data = {1.0, 2.0, 3.0, 4.0};
std::cout << "平均值: " << average(data) << std::endl;
}
// ============================
// 示例7:as_bytes 和 as_writable_bytes
// ============================
void bytes_demo() {
int arr[] = {1, 2, 3};
std::span<int> s(arr);
// 获取底层字节视图(只读)
auto bytes = std::as_bytes(s);
std::cout << "字节数: " << bytes.size() << std::endl;
// 3 * sizeof(int) = 12 字节
// 获取可写字节视图
auto writable_bytes = std::as_writable_bytes(s);
// 可以直接操作原始内存(小心使用)
}
int main() {
std::cout << "=== 数组退化 ===" << std::endl;
decay_demo();
std::cout << "\n=== 静态/动态范围 ===" << std::endl;
extent_demo();
std::cout << "\n=== 边界检查 ===" << std::endl;
bounds_demo();
std::cout << "\n=== 子视图 ===" << std::endl;
subview_demo();
std::cout << "\n=== 最佳实践 ===" << std::endl;
best_practice_demo();
std::cout << "\n=== 字节视图 ===" << std::endl;
bytes_demo();
return 0;
}span 的边界安全特性
| 操作 | 是否检查边界 | 越界后果 |
|---|---|---|
| operator[] | 不检查 | 未定义行为 |
| front() / back() | 不检查空 | 未定义行为 |
| first(n) | 不检查 | 未定义行为 |
| last(n) | 不检查 | 未定义行为 |
| subspan(off, count) | 不检查 | 未定义行为 |
| size() / empty() | 安全 | 无越界风险 |
| data() | 安全 | 返回指针 |
静态范围 vs 动态范围
| 特性 | 静态范围 span<T, N> | 动态范围 span<T> |
|---|---|---|
| 大小 | 编译期已知 | 运行时确定 |
| sizeof | sizeof(T*) | sizeof(T*) + sizeof(size_t) |
| 转换 | 可转为动态范围 | 不能转为静态范围 |
| 编译器优化 | 更好(大小已知) | 一般 |
| 灵活性 | 低(大小固定) | 高 |
span vs 其他视图
| 特性 | std::span | std::string_view | ranges view |
|---|---|---|---|
| 数据类型 | 任意 T | char | 任意 |
| 连续内存 | 是 | 是 | 不一定 |
| 可修改 | span<T> 可以 | 不可以 | 取决于视图 |
| 拥有数据 | 不拥有 | 不拥有 | 不拥有 |
| 大小信息 | 有 | 有 | 有 |
常见问题
span 的 operator[] 为什么不做边界检查?
和标准库容器(vector, array)的 operator[] 一样,span 的 operator[] 不做检查是为了零开销抽象。检查版本可以自己封装,或者使用某些编译器的调试模式(如 MSVC 的 _CONTAINER_DEBUG_LEVEL)。标准的理念是:不为你不用的东西付费。
span 和裸指针+大小比,安全在哪?
span 把指针和大小绑定在一起,不可能传错大小或忘记传大小。它提供了 size()、empty()、begin/end 等接口,可以用 range-based for 遍历。虽然 operator[] 不做边界检查,但相比裸指针至少有了大小信息可以自行检查。
什么时候用静态范围,什么时候用动态范围?
如果编译期就知道大小(如固定大小的数组、协议包的固定字段),用静态范围 span<T, N>。如果大小在运行时确定(如 vector、用户输入),用动态范围 span<T>。静态范围的好处是编译器可以做更多优化,且某些错误在编译期就能发现。
适用场景
- 替代 (pointer, size) 函数参数对
- 统一接受 C 数组、vector、array 的函数接口
- 传递连续内存的只读或可写视图
- 零拷贝的数据切片(subspan)
注意事项
- span 不拥有数据,必须保证底层数据存活
- operator[] 和子视图操作不做边界检查
- 动态范围和静态范围不能自由互转
- span 不能用于非连续容器(如 list、deque)
- 修改 span 指向的数据会修改底层容器的数据
总结
std::span 通过把指针和大小绑定在一起,解决了 C 数组退化丢失大小信息的问题。它有静态范围(大小编码在类型中)和动态范围(大小在运行时确定)两种模式。虽然 operator[] 不做边界检查,但提供了 size()、empty() 等接口让开发者可以自行检查。面试中要能解释 span 如何改善指针+大小的传统接口、静态和动态范围的区别、以及 span 不拥有数据带来的生命周期问题。