C++20 ‘std::span’ 与 ‘std::string_view’：如何实现无拷贝的连续内存视图切换？ - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

C++20 `std::span` 与 `std::string_view`：无拷贝连续内存视图切换的艺术

在现代C++编程中，性能优化和资源高效利用始终是核心议题。处理连续内存，尤其是字符串和数组，往往伴随着不必要的内存拷贝和分配，这可能导致性能瓶颈、内存碎片化以及不必要的资源消耗。C++17引入的 std::string_view 和 C++20引入的 std::span 正是为了解决这些问题而生。它们提供了一种非拥有（non-owning）的连续内存视图机制，使得程序能够以零拷贝的方式访问和操作内存区域。

本讲座将深入探讨 std::string_view 和 std::span 的设计理念、核心特性、使用场景及其潜在陷阱。更重要的是，我们将聚焦于如何利用它们实现不同类型连续内存视图之间的无缝、零拷贝切换，从而构建更高效、更灵活的C++应用程序。

一、内存视图的必要性：传统方法的局限

在C++17/20之前，处理字符串和数组通常有以下几种方式：

C风格字符串 (const char*) 和指针/长度对 (T*, size_t)：
- 优点：零拷贝，直接操作内存。
- 缺点：缺乏类型安全，容易出错（忘记传递长度，长度与指针不匹配），字符串操作不便，无法与STL算法无缝集成。
std::string 和 std::vector：
- 优点：自动内存管理，功能丰富，类型安全。
- 缺点：当仅需读取或部分访问数据时，频繁的 std::string::substr() 或 std::vector 的切片操作可能导致大量不必要的内存拷贝和堆分配，尤其是在解析器、网络协议处理等场景下。
引用 (const std::string&, const std::vector<T>&)：
- 优点：避免拷贝，传递效率高。
- 缺点：接口不够通用，无法直接处理C风格数组、字符串字面量或不同容器类型。如果函数需要处理 std::string 或 const char* 或 std::vector<char>，则需要重载多个版本，或使用模板，增加了接口的复杂性。

这些传统方法在特定场景下表现良好，但在需要统一、高效、零拷贝地处理多种连续内存源时，它们显得力不从心。std::string_view 和 std::span 正是填补了这一空白。

二、`std::string_view` 深度解析：字符串的非拥有视图

std::string_view 是C++17引入的标准库类型，它提供了一个对字符序列的只读、非拥有视图。这意味着 std::string_view 仅仅指向一个已存在的字符序列（例如C风格字符串、std::string 对象的一部分），并记录其长度。它不拥有所指向的内存，也不负责内存的生命周期管理。

2.1 基本概念与设计哲学

std::string_view 的核心设计思想是“所有权与视图分离”。它仅仅是一个轻量级的对象，内部通常只包含一个指向字符数据起始位置的指针和一个表示长度的整数。

非拥有性：std::string_view 不会在构造、拷贝或赋值时分配任何堆内存。它只是引用外部的内存区域。
只读性：尽管其内部可能指向一个可写的字符数组，但 std::string_view 的接口通常提供 const char* 访问，这意味着它主要用于读取操作，不鼓励通过 string_view 来修改底层数据。
零拷贝：所有的 string_view 操作，如 substr()、remove_prefix() 等，都只是修改其内部的指针和长度，而不会创建新的字符缓冲区。

它解决了以下问题：

统一接口：可以作为函数参数，接受 std::string、C风格字符串字面量、const char* 等多种字符串源，而无需拷贝。
高效子串操作：提取子串不再需要创建新的 std::string 对象，显著提升解析性能。
避免临时对象：在字符串字面量和函数参数之间传递时，可以避免不必要的 std::string 临时对象的创建。

2.2 核心特性与构造方式

std::string_view 的构造非常灵活：

#include <iostream>
#include <string>
#include <string_view> // C++17

void process_string_view(std::string_view sv) {
    std::cout << "  View: "" << sv << "", Length: " << sv.length() << std::endl;
}

int main() {
    // 1. 从 C 风格字符串字面量
    std::string_view sv1 = "Hello C++20!";
    std::cout << "sv1 (literal):" << std::endl;
    process_string_view(sv1);

    // 2. 从 std::string
    std::string s_source = "This is a std::string.";
    std::string_view sv2 = s_source;
    std::cout << "sv2 (from std::string):" << std::endl;
    process_string_view(sv2);

    // 3. 从 C 风格字符数组 (char*) 和长度
    const char* c_str_source = "Raw C-string data.";
    size_t c_str_len = std::strlen(c_str_source);
    std::string_view sv3(c_str_source, c_str_len);
    std::cout << "sv3 (from char* and len):" << std::endl;
    process_string_view(sv3);

    // 4. 从部分 std::string
    std::string_view sv4(s_source.data() + 5, 2); // 从 "is" 开始取 2 个字符
    std::cout << "sv4 (part of std::string):" << std::endl;
    process_string_view(sv4); // Output: "is"

    // 5. 使用字面量后缀 (C++17)
    using namespace std::literals::string_view_literals;
    std::string_view sv5 = "Literal Suffix"_sv;
    std::cout << "sv5 (literal suffix):" << std::endl;
    process_string_view(sv5);

    // 6. 从一个空字符串字面量
    std::string_view sv_empty = "";
    std::cout << "sv_empty (empty literal):" << std::endl;
    process_string_view(sv_empty);

    return 0;
}

2.3 成员函数与操作

std::string_view 提供了一系列与 std::string 类似的成员函数，但所有这些操作都是零拷贝的：

length() / size()：返回视图的长度。
empty()：检查视图是否为空。
operator[]：访问指定索引的字符。
data()：返回指向视图起始字符的 const char* 指针。
substr(pos, count)：返回一个从 pos 开始，长度为 count 的新 string_view。这是零拷贝的。
remove_prefix(n)：移除视图前 n 个字符。
remove_suffix(n)：移除视图后 n 个字符。
front(), back()：访问第一个和最后一个字符。
starts_with(), ends_with() (C++20)：检查视图是否以某个前缀或后缀开始/结束。
find(), rfind(), find_first_of(), find_last_of(), find_first_not_of(), find_last_not_of()：查找字符或子串，返回索引。

#include <iostream>
#include <string_view>
#include <string>

int main() {
    std::string_view sv = "Hello, World! C++20 is great.";

    std::cout << "Original view: "" << sv << """ << std::endl;

    // 1. 获取长度和数据指针
    std::cout << "Length: " << sv.length() << std::endl;
    std::cout << "First char: " << sv[0] << std::endl;
    std::cout << "Raw data pointer: " << static_cast<const void*>(sv.data()) << std::endl;

    // 2. substr() - 零拷贝
    std::string_view sub_sv = sv.substr(7, 5); // "World"
    std::cout << "substr(7, 5): "" << sub_sv << """ << std::endl;
    std::cout << "  substr data pointer: " << static_cast<const void*>(sub_sv.data()) << std::endl; // 与原视图在同一内存区域

    // 3. remove_prefix() 和 remove_suffix() - 零拷贝
    std::string_view modified_sv = sv;
    modified_sv.remove_prefix(7); // "World! C++20 is great."
    modified_sv.remove_suffix(13); // "World!"
    std::cout << "After remove_prefix(7) and remove_suffix(13): "" << modified_sv << """ << std::endl;
    std::cout << "  Modified data pointer: " << static_cast<const void*>(modified_sv.data()) << std::endl; // 仍然在同一内存区域

    // 4. 查找操作
    size_t pos = sv.find("C++20");
    if (pos != std::string_view::npos) {
        std::cout << ""C++20" found at position: " << pos << std::endl;
        std::cout << "View from "C++20": "" << sv.substr(pos) << """ << std::endl;
    }

    // 5. 比较操作
    std::string_view sv_comp1 = "apple";
    std::string_view sv_comp2 = "banana";
    std::string_view sv_comp3 = "apple";
    std::cout << "sv_comp1 == sv_comp2: " << (sv_comp1 == sv_comp2) << std::endl; // 0
    std::cout << "sv_comp1 == sv_comp3: " << (sv_comp1 == sv_comp3) << std::endl; // 1

    return 0;
}

2.4 生命周期管理与陷阱

std::string_view 的最大风险在于其非拥有性。如果 string_view 引用的底层字符串数据被销毁或移动，那么 string_view 就会变成悬空视图（dangling view），访问它将导致未定义行为。

#include <iostream>
#include <string>
#include <string_view>

std::string_view get_dangling_view() {
    std::string temp_str = "This is a temporary string.";
    // temp_str 在函数返回时销毁
    return temp_str; // 警告：返回对局部变量的引用
}

int main() {
    std::string_view sv = get_dangling_view();
    // 此时 temp_str 已经销毁，sv 是悬空的
    std::cout << "Dangling view (UB): " << sv << std::endl; // 未定义行为

    // 正确的做法：确保源数据生命周期长于视图
    std::string s_data = "Longer lived string data.";
    std::string_view valid_sv = s_data;
    std::cout << "Valid view: " << valid_sv << std::endl;

    // 即使源数据是动态分配的，也必须保证其生命周期
    std::string* heap_str = new std::string("Heap allocated string.");
    std::string_view heap_sv = *heap_str;
    std::cout << "Heap view: " << heap_sv << std::endl;
    delete heap_str; // 此时 heap_sv 变成悬空
    // std::cout << "Dangling heap view (UB): " << heap_sv << std::endl; // 未定义行为

    return 0;
}

因此，在使用 std::string_view 时，必须时刻警惕其底层数据源的生命周期。作为函数参数传递时，它非常安全且高效；但作为成员变量或函数返回值时，需要仔细设计以避免悬空问题。

三、`std::span` 深度解析：通用连续内存的非拥有视图

std::span 是C++20引入的标准库类型，它提供了一个对任意类型连续内存序列的非拥有视图。与 std::string_view 专注于字符序列不同，std::span 是一个通用的视图类型，可以用于任何T类型的数据。

3.1 基本概念与设计哲学

std::span 的设计哲学与 std::string_view 类似，也是“所有权与视图分离”。它封装了一个指针（或迭代器）和一个长度，指向一段连续的内存区域。

非拥有性：std::span 不管理所指向内存的生命周期。
通用性：可以用于 std::vector<T>、std::array<T, N>、C风格数组、原始指针和长度对等多种连续内存源。
读写或只读：std::span<T> 提供读写访问，而 std::span<const T> 提供只读访问，这增加了类型安全性。
零拷贝：所有操作，如 subspan()、first()、last() 等，都只涉及指针和长度的调整，不会触发内存分配或数据拷贝。
编译期/运行时长度：std::span 有两个模板参数：T (元素类型) 和 Extent (编译期已知长度)。
- std::span<T> (或 std::span<T, std::dynamic_extent>)：表示运行时才确定长度的 span。这是最常见的形式。
- std::span<T, N>：表示编译期已知长度为 N 的 span。这提供了额外的编译期检查。

它解决了以下问题：

统一不同容器的接口：一个函数可以接受 std::vector<T>、std::array<T, N>、C风格数组等作为参数，而无需重载或模板推导，简化了API设计。
避免原始指针/长度对：取代了 (T*, size_t) 这种容易出错的模式，提高了类型安全性和可读性。
高效子范围操作：像 std::string_view 一样，可以零拷贝地获取子范围。

3.2 核心特性与构造方式

std::span 的构造方式也非常灵活：

#include <iostream>
#include <vector>
#include <array>
#include <span> // C++20

void process_data_span(std::span<int> data) {
    std::cout << "  Span (RW) data: [";
    for (int& val : data) {
        val *= 2; // 可以修改数据
        std::cout << val << " ";
    }
    std::cout << "], Length: " << data.size() << std::endl;
}

void process_const_data_span(std::span<const int> data) {
    std::cout << "  Span (RO) data: [";
    for (const int& val : data) {
        std::cout << val << " ";
    }
    std::cout << "], Length: " << data.size() << std::endl;
}

int main() {
    // 1. 从 C 风格数组
    int c_array[] = {1, 2, 3, 4, 5};
    std::span<int> span1(c_array);
    std::cout << "span1 (from C-array):" << std::endl;
    process_data_span(span1); // 修改 c_array
    process_const_data_span(span1); // 读取修改后的 c_array

    // 2. 从 std::vector
    std::vector<int> vec_source = {10, 20, 30, 40, 50, 60};
    std::span<int> span2(vec_source);
    std::cout << "span2 (from std::vector):" << std::endl;
    process_data_span(span2); // 修改 vec_source
    process_const_data_span(span2);

    // 3. 从 std::array
    std::array<int, 4> arr_source = {100, 200, 300, 400};
    std::span<int> span3(arr_source);
    std::cout << "span3 (from std::array):" << std::endl;
    process_data_span(span3); // 修改 arr_source
    process_const_data_span(span3);

    // 4. 从原始指针和长度
    int* raw_ptr = new int[3]{7, 8, 9};
    std::span<int> span4(raw_ptr, 3);
    std::cout << "span4 (from raw ptr and len):" << std::endl;
    process_data_span(span4);
    delete[] raw_ptr; // 清理动态内存

    // 5. 从部分容器
    std::span<const int> span5(vec_source.data() + 2, 3); // 从 vec_source 的第三个元素开始取 3 个元素 (30, 80, 100)
    std::cout << "span5 (part of std::vector, const):" << std::endl;
    process_const_data_span(span5);

    // 6. 编译期已知长度的 span
    std::array<double, 3> fixed_arr = {1.1, 2.2, 3.3};
    std::span<double, 3> fixed_span(fixed_arr);
    std::cout << "fixed_span (compile-time extent): [";
    for (double val : fixed_span) {
        std::cout << val << " ";
    }
    std::cout << "]" << std::endl;

    // 7. 从 const 容器创建 span<const T>
    const std::vector<float> const_vec = {0.1f, 0.2f, 0.3f};
    std::span<const float> const_span(const_vec);
    std::cout << "const_span (from const std::vector): [";
    for (float val : const_span) {
        std::cout << val << " ";
    }
    std::cout << "]" << std::endl;

    return 0;
}

需要注意的是，std::vector<bool> 是一个特例，它不是一个连续的内存块，因此不能直接转换为 std::span<bool>。

3.3 成员函数与操作

std::span 提供了丰富且零拷贝的成员函数：

size() / length()：返回 span 中的元素数量。
empty()：检查 span 是否为空。
operator[]：访问指定索引的元素。
data()：返回指向 span 起始元素的指针 (T* 或 const T*)。
first(Count)：返回一个包含前 Count 个元素的新 span。
last(Count)：返回一个包含后 Count 个元素的新 span。
subspan(Offset, Count)：返回一个从 Offset 开始，包含 Count 个元素的新 span。
begin(), end()：提供迭代器支持，可用于基于范围的for循环。

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

int main() {
    std::vector<int> data = {10, 20, 30, 40, 50, 60, 70, 80};
    std::span<int> s(data);

    std::cout << "Original span: [";
    for (int x : s) {
        std::cout << x << " ";
    }
    std::cout << "]" << std::endl;

    // 1. 获取基本信息
    std::cout << "Size: " << s.size() << std::endl;
    std::cout << "First element: " << s.front() << std::endl;
    std::cout << "Last element: " << s.back() << std::endl;
    std::cout << "Data pointer: " << static_cast<void*>(s.data()) << std::endl;

    // 2. first() - 零拷贝
    std::span<int> first_three = s.first(3); // {10, 20, 30}
    std::cout << "first(3): [";
    for (int x : first_three) {
        std::cout << x << " ";
    }
    std::cout << "]" << std::endl;
    std::cout << "  first(3) data pointer: " << static_cast<void*>(first_three.data()) << std::endl;

    // 3. last() - 零拷贝
    std::span<int> last_two = s.last(2); // {70, 80}
    std::cout << "last(2): [";
    for (int x : last_two) {
        std::cout << x << " ";
    }
    std::cout << "]" << std::endl;
    std::cout << "  last(2) data pointer: " << static_cast<void*>(last_two.data()) << std::endl;

    // 4. subspan() - 零拷贝
    std::span<int> middle_span = s.subspan(2, 4); // {30, 40, 50, 60}
    std::cout << "subspan(2, 4): [";
    for (int x : middle_span) {
        std::cout << x << " ";
    }
    std::cout << "]" << std::endl;
    std::cout << "  subspan(2, 4) data pointer: " << static_cast<void*>(middle_span.data()) << std::endl;

    // 5. 修改元素 (如果 span 是可写的)
    s[0] = 100;
    std::cout << "Modified original span: [";
    for (int x : s) {
        std::cout << x << " ";
    }
    std::cout << "]" << std::endl;

    return 0;
}

3.4 生命周期管理与陷阱

与 std::string_view 类似，std::span 也是非拥有的，因此也存在悬空视图的风险。如果底层数据源被销毁或移动，std::span 就会失效。

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

std::span<int> get_dangling_span() {
    std::vector<int> temp_vec = {1, 2, 3};
    // temp_vec 在函数返回时销毁
    return temp_vec; // 警告：返回对局部变量的引用
}

int main() {
    std::span<int> s = get_dangling_span();
    // 此时 temp_vec 已经销毁，s 是悬空的
    // std::cout << "Dangling span (UB): " << s[0] << std::endl; // 未定义行为

    // 正确的做法：确保源数据生命周期长于视图
    std::vector<double> valid_data = {10.1, 20.2, 30.3};
    std::span<const double> valid_s(valid_data);
    std::cout << "Valid span: " << valid_s[0] << std::endl;

    // 动态分配的数组
    int* raw_array = new int[5]{1, 2, 3, 4, 5};
    std::span<int> raw_span(raw_array, 5);
    std::cout << "Raw array span: " << raw_span[0] << std::endl;
    delete[] raw_array; // 此时 raw_span 悬空
    // std::cout << "Dangling raw array span (UB): " << raw_span[0] << std::endl; // 未定义行为

    return 0;
}

始终牢记：std::span 和 std::string_view 只是内存的“窗口”，它们不拥有窗口内的景色。一旦景色消失，窗口就变得毫无意义。

四、零拷贝的本质：视图与所有权分离

“零拷贝”在这里指的是在创建视图、传递视图或对视图进行子范围操作时，不会发生实际的数据拷贝。它不是指数据本身不被复制到内存的某个位置，而是指在程序逻辑层面，我们避免了额外的、不必要的数据复制操作。

std::string_view 和 std::span 实现零拷贝的根本机制在于它们将数据所有权与数据视图的概念清晰地分离。

所有权：由 std::string、std::vector、C风格数组或动态分配的内存等实体负责。它们管理内存的分配、释放和实际数据的存储。
视图：由 std::string_view 和 std::span 提供。它们不负责内存管理，只存储一个指向数据起始位置的指针和数据的长度。

当一个 std::string_view 或 std::span 被创建时，它仅仅是复制了指向底层数据的指针和长度这两个标量值。这个操作的开销与复制一个普通指针和整数的开销相当，是 O(1) 的，与底层数据的大小无关。

传统方法如 std::string::substr()，通常会创建一个新的 std::string 对象，这意味着它会：

分配新的堆内存。
将原始字符串的子范围数据拷贝到新分配的内存中。
这两个操作的开销是 O(N) 的，其中 N 是子字符串的长度。在频繁的子串提取和解析场景中，这种开销会迅速累积，导致严重的性能问题。

std::string_view::substr() 和 std::span::subspan() 则只是简单地调整其内部的指针和长度，指向原始内存区域的新的子范围。这正是零拷贝的体现。

性能优势的来源：

避免堆分配/释放：堆操作是昂贵的，零拷贝视图完全规避了这一成本。
减少数据拷贝：数据拷贝会消耗CPU周期和内存带宽，尤其是在大数据量时，零拷贝视图显著减少了这一消耗。
提高缓存命中率：由于所有视图都指向同一块连续内存，CPU缓存更有可能命中所需数据，减少了内存访问延迟。

五、`std::span` 与 `std::string_view` 的协同与转换

尽管 std::string_view 和 std::span 服务于不同的主要目的（字符串 vs. 通用数据），但它们在设计上高度相似，并且可以进行零拷贝的相互转换，从而实现连续内存视图的无缝切换。

5.1 设计哲学上的相似点与区别

特性	`std::string_view`	`std::span`
主要用途	字符串（`char` 或 `wchar_t` 等）的只读视图	任意类型 `T` 的连续内存视图
拥有性	非拥有（non-owning）	非拥有（non-owning）
底层数据	指针和长度	指针和长度
零拷贝操作	是	是
数据类型	仅 `char` (或 `wchar_t`, `char8_t`, `char16_t`, `char32_t`)	任意类型 `T`
读写权限	通常只读 (`const char*`)	`std::span<T>` 可读写，`std::span<const T>` 只读
模板参数	无 (类型固定为 `char`)	`std::span<T, Extent>`，`T` 为元素类型，`Extent` 为编译期长度（可选）
生命周期管理	须自行管理底层数据生命周期	须自行管理底层数据生命周期

从本质上讲，std::string_view 可以被视为 std::span<const char> 的特化版本，额外增加了字符串特有的语义和操作（如 find 等）。

5.2 从 `std::string_view` 到 `std::span<const char>`

由于 std::string_view 内部存储 const char* 指针和长度，它可以直接用来构造 std::span<const char>。这是一个零拷贝操作，因为 span 只是简单地复制了 string_view 的内部指针和长度。

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

int main() {
    std::string_view sv = "Hello, C++20 Views!";

    // 从 std::string_view 构造 std::span<const char>
    std::span<const char> char_span(sv.data(), sv.size());

    std::cout << "Original string_view: "" << sv << """ << std::endl;
    std::cout << "  string_view data ptr: " << static_cast<const void*>(sv.data()) << std::endl;
    std::cout << "Converted span<const char>: [";
    for (char c : char_span) {
        std::cout << c;
    }
    std::cout << "]" << std::endl;
    std::cout << "  span<const char> data ptr: " << static_cast<const void*>(char_span.data()) << std::endl;

    // 验证它们指向同一块内存
    if (sv.data() == char_span.data() && sv.size() == char_span.size()) {
        std::cout << "Conversion was zero-copy and points to the same memory." << std::endl;
    }

    return 0;
}

这种转换非常有用，例如当一个通用函数需要处理字节数据（std::span<const char> 或 std::span<const std::byte>），而你的输入是一个 std::string_view 时。

5.3 从 `std::span<const char>` 到 `std::string_view`

反向转换同样是零拷贝的，因为 std::string_view 也可以通过 const char* 和长度来构造。

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

int main() {
    std::vector<char> char_data = {'S', 'P', 'A', 'N', '_', 'T', 'O', '_', 'S', 'V'};
    std::span<const char> char_span(char_data.data(), char_data.size());

    // 从 std::span<const char> 构造 std::string_view
    std::string_view sv(char_span.data(), char_span.size());

    std::cout << "Original span<const char>: [";
    for (char c : char_span) {
        std::cout << c;
    }
    std::cout << "]" << std::endl;
    std::cout << "  span<const char> data ptr: " << static_cast<const void*>(char_span.data()) << std::endl;
    std::cout << "Converted string_view: "" << sv << """ << std::endl;
    std::cout << "  string_view data ptr: " << static_cast<const void*>(sv.data()) << std::endl;

    if (char_span.data() == sv.data() && char_span.size() == sv.size()) {
        std::cout << "Conversion was zero-copy and points to the same memory." << std::endl;
    }

    return 0;
}

这在处理通用字节流，其中一部分需要被解释为文本字符串时非常有用。

5.4 从 `std::span<char>` 到 `std::string_view`

如果有一个可写的 std::span<char>，也可以将其转换为 std::string_view。同样是零拷贝。
需要注意的是，尽管 span<char> 是可写的，但 string_view 仍然会提供 const char* 接口。这意味着你不能通过 string_view 来修改原始数据，但你可以通过原始的 span<char> 来修改。

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

int main() {
    std::vector<char> buffer = {'A', 'B', 'C', 'D', 'E', 'F'};
    std::span<char> writable_span(buffer);

    std::cout << "Original buffer: [";
    for (char c : buffer) {
        std::cout << c;
    }
    std::cout << "]" << std::endl;

    // 通过 span 修改数据
    writable_span[0] = 'X';
    writable_span[1] = 'Y';

    // 从 std::span<char> 构造 std::string_view
    std::string_view sv(writable_span.data(), writable_span.size());

    std::cout << "Modified buffer via span: [";
    for (char c : buffer) {
        std::cout << c;
    }
    std::cout << "]" << std::endl;
    std::cout << "Converted string_view: "" << sv << """ << std::endl;

    // 尝试通过 string_view 修改数据 (编译错误或 UB)
    // sv[0] = 'Z'; // 编译错误：expression must be a modifiable lvalue

    return 0;
}

5.5 从 `std::string` 到 `std::span<char>` 或 `std::span<const char>`

std::string 在 C++11 之后保证其数据是连续存储的，并且 data() 方法返回的是可写的 char*（如果 string 不是 const）。这使得从 std::string 创建 std::span 变得简单且零拷贝。

#include <iostream>
#include <string>
#include <span>

int main() {
    std::string my_string = "Mutable String Data";

    // 从 std::string 构造 std::span<char> (可写)
    std::span<char> writable_span(my_string);

    std::cout << "Original string: "" << my_string << """ << std::endl;
    std::cout << "  String data ptr: " << static_cast<void*>(my_string.data()) << std::endl;

    // 通过 span 修改 string 的内容
    writable_span[0] = 'M';
    writable_span[1] = 'U';
    writable_span[2] = 'T';

    std::cout << "Modified string via span: "" << my_string << """ << std::endl;

    // 从 const std::string 构造 std::span<const char> (只读)
    const std::string const_string = "Constant String Data";
    std::span<const char> const_span(const_string);

    std::cout << "Constant string: "" << const_string << """ << std::endl;
    std::cout << "  Const span data ptr: " << static_cast<const void*>(const_span.data()) << std::endl;

    // 尝试通过 const_span 修改数据 (编译错误)
    // const_span[0] = 'X'; // 编译错误

    return 0;
}

5.6 从 `std::vector<char>` 到 `std::span<char>` 或 `std::span<const char>`

std::vector 的数据也保证是连续存储的，因此与 std::string 类似，可以零拷贝地转换为 std::span。

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

int main() {
    std::vector<char> byte_buffer = {'R', 'A', 'W', ' ', 'B', 'Y', 'T', 'E', 'S'};

    // 从 std::vector<char> 构造 std::span<char> (可写)
    std::span<char> writable_byte_span(byte_buffer);

    std::cout << "Original vector: [";
    for (char c : byte_buffer) {
        std::cout << c;
    }
    std::cout << "]" << std::endl;

    // 通过 span 修改 vector 的内容
    writable_byte_span[0] = 'B';
    writable_byte_span[1] = 'I';
    writable_byte_span[2] = 'N';

    std::cout << "Modified vector via span: [";
    for (char c : byte_buffer) {
        std::cout << c;
    }
    std::cout << "]" << std::endl;

    // 从 const std::vector<char> 构造 std::span<const char> (只读)
    const std::vector<char> const_byte_buffer = {'C', 'O', 'N', 'S', 'T', ' ', 'D', 'A', 'T', 'A'};
    std::span<const char> const_byte_span(const_byte_buffer);

    std::cout << "Constant vector: [";
    for (char c : const_byte_span) {
        std::cout << c;
    }
    std::cout << "]" << std::endl;

    return 0;
}

5.7 通用字节流处理中的视图切换

一个典型的场景是网络协议解析或文件I/O。我们可能接收到一个原始的字节流（例如 std::vector<char> 或 std::span<std::byte>），其中包含文本和二进制数据。

初始数据：通常是 std::span<char> 或 std::span<std::byte>。
提取文本部分：将 std::span<char> 的子范围转换为 std::string_view 进行文本解析（例如，解析HTTP头部的键值对）。
提取二进制结构：将 std::span<char> 或 std::span<std::byte> 的子范围转换为 std::span<const MyStruct> 或 std::span<MyStruct>，用于直接解释为C++结构体（例如，解析自定义协议消息体中的定长头部）。

这种切换是零拷贝的，并且允许我们在不同的解析阶段使用最合适的视图类型。

表格：视图转换概览（零拷贝）

源视图/容器	目标视图	构造方式	备注
`std::string_view`	`std::span<const char>`	`std::span<const char>(sv.data(), sv.size())`	`string_view` 本质上就是 `span<const char>`
`std::span<const char>`	`std::string_view`	`std::string_view(span.data(), span.size())`
`std::span<char>`	`std::string_view`	`std::string_view(span.data(), span.size())`	`string_view` 仍为只读
`std::string`	`std::span<char>`	`std::span<char>(str)`	C++11+ `str.data()` 可写
`std::string`	`std::span<const char>`	`std::span<const char>(str)`
`std::vector<T>`	`std::span<T>`	`std::span<T>(vec)`	`std::vector<bool>` 是特例
`std::vector<T>`	`std::span<const T>`	`std::span<const T>(vec)`
C风格数组 `T[]`	`std::span<T>`	`std::span<T>(arr)`
`T*`, `size_t`	`std::span<T>`	`std::span<T>(ptr, count)`	需手动管理生命周期

六、实际案例分析：构建一个简单的协议解析器

假设我们正在开发一个简单的文本协议解析器。协议消息格式如下：

COMMAND_NAME:param1=value1;param2=value2;...

例如：LOGIN:user=test;pass=12345; 或 DATA:id=100;payload=some_base64_data;

我们将使用 std::string_view 和 std::span 来实现一个高效的零拷贝解析器。

#include <iostream>
#include <string>
#include <string_view>
#include <span>
#include <vector>
#include <map>
#include <stdexcept>

// 辅助函数：将字符串视图转换为整数
int sv_to_int(std::string_view sv) {
    size_t pos;
    // std::stoi 接受 std::string，我们需要一个辅助转换
    // 或者手动解析，这里为了简化演示使用 std::string 构造
    return std::stoi(std::string(sv), &pos);
    // 实际生产代码会更严谨地处理错误和转换
}

struct ProtocolMessage {
    std::string_view command;
    std::map<std::string_view, std::string_view> params;

    void print() const {
        std::cout << "Command: " << command << std::endl;
        std::cout << "Params:" << std::endl;
        for (const auto& [key, value] : params) {
            std::cout << "  " << key << " = " << value << std::endl;
        }
    }
};

// 协议解析函数
ProtocolMessage parse_protocol_message(std::string_view message_sv) {
    ProtocolMessage msg;

    // 1. 查找命令名和参数分隔符 ':'
    size_t colon_pos = message_sv.find(':');
    if (colon_pos == std::string_view::npos) {
        throw std::runtime_error("Invalid message format: missing colon.");
    }

    // 提取命令名 (零拷贝)
    msg.command = message_sv.substr(0, colon_pos);

    // 移除已解析的命令名和冒号，得到参数部分 (零拷贝)
    std::string_view params_sv = message_sv.substr(colon_pos + 1);

    // 2. 解析参数列表
    size_t current_param_start = 0;
    while (current_param_start < params_sv.length()) {
        size_t semicolon_pos = params_sv.find(';', current_param_start);
        std::string_view param_pair_sv;

        if (semicolon_pos == std::string_view::npos) {
            // 这是最后一个参数
            param_pair_sv = params_sv.substr(current_param_start);
            current_param_start = params_sv.length(); // 结束循环
        } else {
            param_pair_sv = params_sv.substr(current_param_start, semicolon_pos - current_param_start);
            current_param_start = semicolon_pos + 1;
        }

        if (!param_pair_sv.empty()) {
            size_t eq_pos = param_pair_sv.find('=');
            if (eq_pos == std::string_view::npos) {
                // 忽略格式错误的参数，或抛出异常
                std::cerr << "Warning: Malformed parameter: " << param_pair_sv << std::endl;
                continue;
            }
            std::string_view key = param_pair_sv.substr(0, eq_pos);
            std::string_view value = param_pair_sv.substr(eq_pos + 1);
            msg.params[key] = value; // map 的 key 和 value 都是 string_view，零拷贝
        }
    }

    return msg;
}

// 假设我们有一个处理原始字节数据的函数
void process_raw_bytes(std::span<char> buffer) {
    // 模拟一些处理，例如接收网络数据
    std::cout << "nProcessing raw bytes buffer (length: " << buffer.size() << "):" << std::endl;
    std::string test_message = "LOGIN:user=admin;pass=secure_pass;token=xyz123;";
    if (buffer.size() >= test_message.length()) {
        std::copy(test_message.begin(), test_message.end(), buffer.begin());
        std::cout << "  Injected test message into buffer." << std::endl;
    } else {
        std::cerr << "Buffer too small for test message." << std::endl;
    }
}

int main() {
    // 场景1: 从 std::string 原始消息解析
    std::string raw_message_str = "LOGIN:user=john.doe;pass=secret123;id=456;role=user;";
    std::cout << "--- Parsing from std::string ---" << std::endl;
    try {
        ProtocolMessage msg1 = parse_protocol_message(raw_message_str); // 隐式转换为 string_view
        msg1.print();
        // 访问特定参数并转换为其他类型
        if (msg1.params.count("id")) {
            int id = sv_to_int(msg1.params["id"]);
            std::cout << "  Parsed ID: " << id << std::endl;
        }
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    // 场景2: 从 C 风格字符串字面量解析
    std::cout << "n--- Parsing from C-style literal ---" << std::endl;
    std::string_view literal_message = "DATA:sensor=temp;value=25.5;unit=celsius;";
    try {
        ProtocolMessage msg2 = parse_protocol_message(literal_message);
        msg2.print();
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    // 场景3: 模拟从网络接收字节流，然后解析
    // 使用 std::vector<char> 模拟接收缓冲区
    std::vector<char> network_buffer(100);
    // 将 vector 转换为 span<char> 传递给底层函数
    process_raw_bytes(std::span<char>(network_buffer));

    // 现在，将 span<char> 转换为 string_view 进行解析 (零拷贝)
    std::string_view received_message_sv(network_buffer.data(), network_buffer.size());
    // 由于 process_raw_bytes 注入了消息，我们需要找到实际消息的长度
    size_t actual_msg_len = received_message_sv.find(';'); // 找到第一个分号 (或其他结束符)
    if (actual_msg_len == std::string_view::npos) { // 消息可能没有分号，或者太短
        actual_msg_len = received_message_sv.length(); // 假设整个缓冲区都是消息
    } else {
        // 确保包含整个注入消息，这里简单处理
        actual_msg_len = std::string("LOGIN:user=admin;pass=secure_pass;token=xyz123;").length();
    }
    received_message_sv = received_message_sv.substr(0, actual_msg_len); // 截取实际消息

    std::cout << "n--- Parsing from std::span (network buffer) ---" << std::endl;
    try {
        ProtocolMessage msg3 = parse_protocol_message(received_message_sv);
        msg3.print();
        if (msg3.params.count("token")) {
            std::cout << "  Parsed Token: " << msg3.params["token"] << std::endl;
        }
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    // 场景4: 错误消息格式
    std::cout << "n--- Parsing malformed message ---" << std::endl;
    std::string_view malformed_message = "INVALID_COMMAND_NO_COLON";
    try {
        parse_protocol_message(malformed_message);
    } catch (const std::exception& e) {
        std::cerr << "Caught expected error: " << e.what() << std::endl;
    }

    return 0;
}

在这个案例中：

parse_protocol_message 函数接受 std::string_view 作为参数，这意味着它能零拷贝地处理 std::string、C风格字符串字面量以及从 std::span<char> 转换而来的视图。
find() 和 substr() 等操作在 std::string_view 上都是零拷贝的。每次提取命令、参数键或参数值，都只是创建了一个新的 std::string_view，指向原始消息的不同部分，而没有进行任何内存分配或拷贝。
ProtocolMessage 结构体中的 command 和 params 的键值对都存储为 std::string_view，进一步保证了整个解析过程的零拷贝性。
process_raw_bytes 函数接受 std::span<char>，这使其能够处理任何可写的连续 char 缓冲区，无论是 std::vector<char> 还是 C 风格数组。
从 network_buffer (一个 std::vector<char>) 到 std::span<char>，再到 std::string_view 的转换，都完美地实现了零拷贝。

七、性能考量与最佳实践

std::string_view 和 std::span 带来了显著的性能提升和代码简化，但也引入了新的考量。

7.1 性能优势

减少内存分配和释放：这是最大的性能增益。堆操作通常是程序中最慢的操作之一。
降低数据拷贝开销：避免将数据从一个位置复制到另一个位置，节省CPU周期和内存带宽。
改善CPU缓存效率：由于视图指向现有内存，数据更有可能已经在CPU缓存中，从而加速访问。
O(1) 的子范围操作：substr()、subspan()、remove_prefix() 等操作的时间复杂度与视图大小无关。

7.2 生命周期管理是关键

这是使用视图时最重要也是最容易出错的地方。务必确保视图的底层数据源在视图的整个生命周期内都是有效且未被修改的。

避免返回悬空视图：函数不应返回指向其内部局部变量的视图。
成员变量视图：将视图作为类成员变量时要极其谨慎。只有当你知道这个视图的底层数据源的生命周期肯定长于或等于这个类实例的生命周期时，才应该这样做。否则，考虑存储拥有型数据（如 std::string 或 std::vector）。

7.3 常量正确性

尽可能使用 std::string_view (它本质上是 const char* 视图) 和 std::span<const T>。这不仅能提供更强的类型安全保障，还能清晰地表达你的意图：你只是想读取数据，而不是修改它。
只有当你确实需要修改底层数据时，才使用 std::span<T>。

7.4 与拥有型容器的集成

视图不是容器的替代品，而是容器的补充。它们是“桥梁”，用于在不同的容器、C风格数组或原始指针之间传递数据，而无需额外的拷贝。它们通常与 std::string、std::vector、std::array 等拥有型容器协同工作。

7.5 不要将视图存储为成员变量（除非非常小心）

如前所述，作为成员变量的视图是悬空风险的主要来源。如果类的生命周期可能长于它所引用的数据，那么存储 std::string 或 std::vector 这样的拥有型数据是更安全的选择。

7.6 返回视图的危险性

从函数返回 std::string_view 或 std::span 往往是危险的，因为它可能指向函数内部的局部变量，导致返回的视图立即悬空。

std::string_view get_name() {
    std::string name = "LocalName";
    return name; // 错误：name在函数结束后销毁
}

std::span<int> get_data() {
    int arr[] = {1, 2, 3};
    return arr; // 错误：arr在函数结束后销毁
}

正确地返回视图通常意味着底层数据由调用者管理或由堆分配并由智能指针管理。

7.7 何时不使用视图

需要修改数据且需要数据所有权：如果函数需要修改数据并且修改应该独立于原始数据，或者函数需要负责数据的生命周期，那么应该拷贝数据并使用 std::string 或 std::vector。
源数据生命周期复杂且难以管理：在某些复杂的异步或多线程场景中，跟踪底层数据的生命周期可能变得非常困难。此时，为了安全起见，拷贝数据可能是更好的选择。
数据量非常小：对于极小的数据量（例如几个字符或几个整数），视图带来的性能提升可能不明显，甚至由于额外的间接访问而略有下降。此时，直接拷贝或使用值传递可能更简单。

八、展望未来：Ranges 与视图的结合

C++20 引入的 Ranges 库与 std::span 和 std::string_view 完美结合，共同构建了现代C++处理序列数据的新范式。Ranges 提供了一种声明式、函数式的风格来处理序列，而 std::span 和 std::string_view 则可以作为 Ranges 的底层数据源。

例如，你可以将一个 std::span 传递给 Ranges 算法，或者使用 std::views::filter、std::views::transform 等视图适配器来创建新的零拷贝视图。

#include <iostream>
#include <vector>
#include <span>
#include <ranges> // C++20
#include <string_view>

int main() {
    std::vector<int> numbers = {1, 5, 2, 8, 3, 9, 4, 6, 7};
    std::span<const int> num_span(numbers);

    // 使用 Ranges 筛选偶数并乘以2，全部是零拷贝的视图操作
    std::cout << "Even numbers doubled: ";
    for (int x : num_span
                   | std::views::filter([](int n) { return n % 2 == 0; })
                   | std::views::transform([](int n) { return n * 2; })) {
        std::cout << x << " ";
    }
    std::cout << std::endl;

    std::string_view text_sv = "Hello World C++20 Ranges";
    std::cout << "Words in string_view: ";
    // 使用 Ranges 视图分割字符串 (C++23 std::views::split)
    // C++20 需要手动实现或使用第三方库，这里简化演示
    // 假设我们有一个 split 视图
    // for (auto word_sv : text_sv | std::views::split(' ')) {
    //     std::cout << std::string_view(word_sv) << " ";
    // }
    // 暂时用手动方式演示 string_view 的组合
    size_t start = 0;
    size_t end = text_sv.find(' ');
    while (end != std::string_view::npos) {
        std::cout << text_sv.substr(start, end - start) << " ";
        start = end + 1;
        end = text_sv.find(' ', start);
    }
    std::cout << text_sv.substr(start) << std::endl;

    return 0;
}

通过 std::span 和 std::string_view 作为 Ranges 的输入，我们可以构建出极其高效、富有表达力的流水线式数据处理逻辑，而无需在每一步创建新的内存副本。

九、零拷贝视图：现代C++性能与灵活性的基石

std::span 和 std::string_view 是现代C++中处理连续内存的强大工具集。它们通过分离数据所有权与视图，实现了高效的零拷贝操作，显著提升了性能并降低了资源消耗。正确地理解和应用它们，尤其是在不同视图类型之间进行无缝切换时，对于编写高性能、资源友好的C++代码至关重要。尽管它们带来了巨大的便利，但也要求开发者更加关注底层数据的生命周期管理，以避免悬空视图带来的未定义行为。

C++20 std::span 与 std::string_view：无拷贝连续内存视图切换的艺术