C++20中span如何替代原始数组指针安全数组视图的用法-C++-PHP中文网

std::span在c++++20中提供了一种更安全、更现代的方式来表示连续内存区域的视图，它通过封装指针和长度信息解决了原始指针在尺寸缺失、语义模糊、调试困难和维护成本高等问题。1. 它将数据地址与长度打包为一个类型，避免函数调用时需额外传递长度参数的风险；2. 支持从std::vector、c风格数组、std::array、裸指针及另一span构造，具备高度灵活性；3. 可创建子视图而无需复制数据，提升性能与便捷性；4. 与迭代器和范围for循环无缝集成，简化遍历操作并增强代码可读性；5. 被广泛应用于函数参数传递、统一处理不同容器、解析二进制数据、只读访问等场景，提升了接口清晰度与安全性；6. span不管理内存生命周期，开发者需自行确保底层数据的有效性，从而实现职责分离的设计理念。

C++20中span如何替代原始数组指针安全数组视图的用法

std::span

登录后复制

在C++20中提供了一种更安全、更现代的方式来表示连续内存区域的视图，它彻底改变了我们处理原始数组指针的方式，通过封装指针和长度，极大地减少了越界访问等常见错误。

解决方案

std::span

登录后复制

，说白了，就是一个不拥有数据的“视图”类。它本质上就是对一段连续内存的引用，包含了起始地址和长度信息。这和我们以前只传一个裸指针（比如

int* arr

登录后复制

）的做法完全不同，裸指针根本不知道它指向的数组有多长，所以你总得再传一个

size_t size

登录后复制

进去。

std::span

登录后复制

把这两者打包成一个类型，这样一来，你在函数签名里只用写一个

std::span<T>

登录后复制

，就能清晰地表达“我需要一个T类型元素的连续序列，并且我知道它的长度”。

举个例子，以前你可能这么写：

立即学习“C++免费学习笔记（深入）”；

void process_data(int* data, size_t size) {
    for (size_t i = 0; i < size; ++i) {
        // ...
    }
}

std::vector<int> vec = {1, 2, 3, 4, 5};
process_data(vec.data(), vec.size());

int arr[] = {6, 7, 8};
process_data(arr, std::size(arr)); // 或者 sizeof(arr)/sizeof(arr[0])

登录后复制

现在有了

std::span

登录后复制

，代码可以变得更简洁、更安全：

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

void process_data_with_span(std::span<int> data_view) {
    // std::span支持范围for循环，非常方便
    for (int val : data_view) {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    // 也可以像数组一样访问，但它本身不提供at()进行边界检查（除非你自行实现或debug模式下编译器加固）
    // 不过，它的存在本身就鼓励了更安全的编程范式
    if (!data_view.empty()) {
        std::cout << "First element: " << data_view[0] << std::endl;
    }
}

int main() {
    std::vector<int> vec = {10, 20, 30, 40, 50};
    process_data_with_span(vec); // 直接从vector构造span

    int c_array[] = {1, 2, 3};
    process_data_with_span(c_array); // 直接从C风格数组构造span

    // 甚至可以从原始指针和长度构造
    int* raw_ptr = new int[4]{100, 200, 300, 400};
    process_data_with_span({raw_ptr, 4}); // 从指针和长度构造span
    delete[] raw_ptr; // 记得释放内存，span不负责内存管理

    // 还可以创建子视图
    std::span<int> full_span = vec;
    std::span<int> sub_span = full_span.subspan(1, 3); // 从索引1开始，长度为3
    std::cout << "Sub-span: ";
    process_data_with_span(sub_span); // 输出 20 30 40

    return 0;
}

登录后复制

通过

std::span

登录后复制

，我们避免了在函数参数中传递裸指针和长度的二元组，让函数接口更清晰，也降低了调用方传递错误长度的风险。它提供了一种类型安全且富有表达力的数组视图。

为什么我们需要

std::span

登录后复制

？原始指针的痛点究竟在哪里？

在我看来，原始数组指针在C++中一直是个“双刃剑”。它的灵活度很高，直接操作内存，性能自然没得说。但问题是，这种灵活性往往伴随着巨大的风险。最让人头疼的，莫过于“越界访问”这个顽疾。当你只拿着一个

int* p

登录后复制

，你根本不知道

登录后复制

指向的是一个

int

登录后复制

，还是一个

int

登录后复制

数组的第一个元素，更不知道这个数组到底有多长。这就导致了：

尺寸信息缺失：这是核心痛点。函数接收一个
```
int*
```
登录后复制
，它无法得知这个指针背后代表的数组边界。你必须额外传递一个
```
size_t
```
登录后复制
参数，而这个参数很容易在调用时传错，或者在函数内部使用时因为逻辑错误导致越界。
语义模糊：
```
int*
```
登录后复制
既可以表示单个对象的地址，也可以表示数组的起始地址。这种模糊性让代码的意图不那么清晰，增加了阅读和维护的难度。
调试困难：越界访问通常不会立即崩溃，而是导致内存损坏，可能在程序的某个不相关的地方才显现出来，这让调试变得异常艰难，俗称“灵异事件”。
维护成本高：每次使用原始指针，你都得小心翼翼地管理它的边界，这无形中增加了开发者的心智负担，也更容易引入bug。

std::span

登录后复制

的出现，正是为了解决这些痛点。它强制你同时考虑“数据在哪里”和“数据有多长”这两个关键信息，从语言层面就帮你规避了大量因为信息不对称而导致的错误。这不仅仅是语法糖，更是一种设计哲学上的进步，鼓励我们编写更健壮、更易于理解的代码。

std::span

登录后复制

的常见构造方式与实际应用场景

std::span

登录后复制

的构造方式非常灵活，几乎可以从任何连续内存容器或C风格数组中创建，这使得它在现代C++项目中极具实用性。

怪兽AI数字人

数字人短视频创作，数字人直播，实时驱动数字人

查看详情

常见构造方式：

从
std::vector
登录后复制
构造：这是最常见也最方便的方式。

std::span

登录后复制

可以直接从

std::vector

登录后复制

隐式转换而来。

std::vector<double> sensor_readings = {1.2, 3.4, 5.6};
std::span<double> view_readings = sensor_readings; // 隐式转换
// 或者 std::span<double> view_readings(sensor_readings); 显式构造

登录后复制

从C风格数组构造：同样非常直接。

int raw_data[] = {10, 20, 30, 40};
std::span<int> view_raw_data = raw_data; // 隐式转换

登录后复制

从
std::array
登录后复制
构造：
```
std::array
```
登录后复制
是固定大小的C++数组，它也支持直接转换为
```
std::span
```
登录后复制
。
```
std::array<char, 5> buffer = {'H', 'e', 'l', 'l', 'o'};
std::span<char> view_buffer = buffer;
```
登录后复制

从原始指针和长度构造：当你确实只有裸指针和长度信息时，这是必要的。

char* dynamic_buffer = new char[100];
// ... 填充数据
std::span<char> view_dynamic_buffer(dynamic_buffer, 100);
delete[] dynamic_buffer; // span不拥有内存，记得释放

登录后复制

从另一个
std::span
登录后复制
构造（切片）：这是

std::span

登录后复制

非常强大的特性，可以轻松创建原始视图的子视图，而无需复制数据。

std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8};
std::span<int> all_numbers = numbers;
std::span<int> middle_slice = all_numbers.subspan(2, 4); // 从索引2开始，取4个元素 (3, 4, 5, 6)
std::span<int> tail_slice = all_numbers.last(3); // 最后3个元素 (6, 7, 8)

登录后复制

实际应用场景：

函数参数传递：这是
```
std::span
```
登录后复制
最核心的用途。任何需要操作连续数据（如数组、向量、字符串视图）的函数，都可以将参数类型改为
```
std::span<T>
```
登录后复制
或
```
std::span<const T>
```
登录后复制
。这让接口更清晰，更安全，也更通用。
```
// 以前：void process(const int* data, size_t count);
// 现在：void process(std::span<const int> data);
```
登录后复制
统一处理不同类型的连续容器：无论你的数据是存在
```
std::vector
```
登录后复制
、
```
std::array
```
登录后复制
还是C风格数组里，你都可以把它们统一转换为
```
std::span
```
登录后复制
，然后用一套逻辑去处理，避免了为每种容器编写重载函数。
解析二进制数据：在处理网络协议或文件格式时，经常需要将一块原始内存解析成不同的结构体或数组。
```
std::span
```
登录后复制
可以很好地作为这些解析函数的输入，提供安全的视图。
只读访问：如果你只是想查看数据而不修改它，可以使用
```
std::span<const T>
```
登录后复制
，这明确了意图，也提供了编译时检查，防止意外修改。
性能优化：
```
std::span
```
登录后复制
本身是一个轻量级对象，复制和传递的开销极小，因为它只包含一个指针和一个大小。这使得它非常适合在性能敏感的代码路径中作为参数传递。

std::span

登录后复制

的引入，在我看来，是C++向更安全、更现代编程范式迈进的重要一步。它不是一个万能药，但它确实解决了长期困扰C++程序员的原始指针安全问题，并且以一种非常优雅和高效的方式。

std::span

登录后复制

与迭代器、范围for循环的结合使用

std::span

登录后复制

的设计理念之一就是与C++标准库中的其他组件无缝集成，特别是与迭代器和基于范围的for循环。这使得它用起来非常自然，感觉就像操作一个普通的容器一样，而不需要手动进行指针算术或索引管理。

首先，

std::span

登录后复制

完全符合C++的“Range”概念。这意味着它提供了

begin()

登录后复制

和

end()

登录后复制

成员函数，返回指向其内部元素的迭代器。因此，你可以直接在

std::span

登录后复制

上使用基于范围的for循环，这极大地简化了遍历操作：

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

void print_elements(std::span<const int> data_view) {
    std::cout << "Elements: ";
    for (int x : data_view) { // 直接使用范围for循环
        std::cout << x << " ";
    }
    std::cout << std::endl;
}

int main() {
    std::vector<int> my_vec = {100, 200, 300, 400, 500};
    print_elements(my_vec);

    int c_arr[] = {1, 2, 3};
    print_elements(c_arr);

    std::span<int> sub_span = my_vec;
    print_elements(sub_span.subspan(1, 3)); // 对子视图也同样适用

    return 0;
}

登录后复制

这种方式比传统的

for (size_t i = 0; i < data_view.size(); ++i)

登录后复制

或手动管理迭代器更加简洁、可读性更高，也更不容易出错。它让代码的意图一目了然：遍历这个视图中的所有元素。

此外，

std::span

登录后复制

也提供了

cbegin()

登录后复制

、

cend()

登录后复制

、

rbegin()

登录后复制

、

rend()

登录后复制

等成员函数，返回常量迭代器或反向迭代器，这使得它能够支持更复杂的算法和操作，例如使用标准库算法：

#include <iostream>
#include <vector>
#include <span>
#include <numeric> // for std::accumulate
#include <algorithm> // for std::sort

void analyze_span(std::span<int> data) {
    if (data.empty()) {
        std::cout << "Span is empty." << std::endl;
        return;
    }

    // 使用std::accumulate计算和
    long long sum = std::accumulate(data.begin(), data.end(), 0LL);
    std::cout << "Sum: " << sum << std::endl;

    // 查找最大元素
    auto max_it = std::max_element(data.begin(), data.end());
    if (max_it != data.end()) {
        std::cout << "Max element: " << *max_it << std::endl;
    }

    // 对span进行排序 (注意：这会修改原始数据，因为span是非const的)
    std::sort(data.begin(), data.end());
    std::cout << "Sorted span: ";
    for (int x : data) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
}

int main() {
    std::vector<int> values = {5, 1, 9, 3, 7};
    analyze_span(values); // 传递vector的span视图

    int arr[] = {10, 2, 8, 4, 6};
    analyze_span(arr); // 传递C风格数组的span视图

    return 0;
}

登录后复制

这里需要强调的是，