std::span 边界安全检查 ​

面试考点 ​

std::span 是 C++20 引入的轻量级非拥有视图,用于引用连续内存序列。面试官通过这道题考察你是否理解 span 如何解决 C 数组退化为指针丢失大小信息的问题、静态范围和动态范围的区别、以及 span 的边界检查行为。

核心概念 ​

std::span 内部只有一个指针和一个大小值(动态范围时)或只有一个指针(静态范围时,大小编码在类型中)。它不拥有数据,不管理生命周期。span 的 operator[] 不做边界检查(未定义行为),但提供了带检查的访问方式和子视图操作来提高安全性。

基本示例 ​

cpp
#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>
大小编译期已知运行时确定
sizeofsizeof(T*)sizeof(T*) + sizeof(size_t)
转换可转为动态范围不能转为静态范围
编译器优化更好(大小已知)一般
灵活性低(大小固定)高

span vs 其他视图 ​

特性std::spanstd::string_viewranges view
数据类型任意 Tchar任意
连续内存是是不一定
可修改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 不拥有数据带来的生命周期问题。