C++ 字符串处理新纪元：std::string_view 的应用与性能优化

2025/3/4 21:12:41 305 0 0 0

嗨，各位 C++ 程序员们，我是老张，一个在代码世界里摸爬滚打多年的老兵。今天咱们聊聊 C++ 字符串处理这个老生常谈的话题，但这次咱们要关注一个新朋友——std::string_view。相信不少同学都听过它的名字，但可能还没来得及深入了解。没关系，今天咱们就一起来揭开 std::string_view 的神秘面纱，看看它如何在 C++11 及之后的版本中，帮助我们更高效地处理字符串。

为什么我们需要 `std::string_view`？

在 C++ 中，字符串处理一直是个比较棘手的问题。传统的 C 风格字符串（const char*）虽然灵活，但容易出错，而且需要手动管理内存。std::string 虽然提供了更友好的接口，但频繁的字符串拷贝会导致性能下降，尤其是在处理大型字符串或者需要频繁传递字符串的场景下。

想象一下，你正在开发一个文本编辑器，用户输入的内容需要不断地被处理、分析、显示。如果每次处理都进行字符串拷贝，那性能肯定会受到严重影响。再比如，你正在编写一个网络服务器，需要解析客户端发送的 HTTP 请求，如果对每个请求头都进行字符串拷贝，那服务器的吞吐量肯定会大打折扣。

std::string_view 的出现，正是为了解决这些问题。它提供了一种“只读”的字符串视图，避免了不必要的字符串拷贝，从而提高了性能。简单来说，std::string_view 就像是一个“窗口”，你通过这个窗口可以观察到原始字符串的内容，但并不拥有它。这样，你就能够在不修改原始字符串的情况下，高效地访问和操作字符串的子串。

`std::string_view` 是什么？

std::string_view 是 C++17 标准引入的类模板，它定义在 <string_view> 头文件中。它提供了一个非拥有的、只读的字符串视图，可以指向字符串的某个子串，而不需要进行字符串的拷贝。

std::string_view 的核心思想是：它不拥有字符串数据，只是保存了指向字符串数据的指针以及字符串的长度。因此，它的构造、拷贝和赋值操作都非常快，几乎没有任何性能开销。

std::string_view 的主要特点：

非拥有性： std::string_view 并不拥有字符串数据，它只是一个视图，指向字符串的某个部分。因此，当原始字符串被销毁时，std::string_view 就变成了悬挂指针，后续操作可能会导致未定义行为。
只读性： std::string_view 提供的接口都是只读的，你无法通过它修改原始字符串的内容。如果需要修改，需要先将 std::string_view 转换为 std::string。
轻量级： std::string_view 的大小通常很小，因为它只保存了指向字符串数据的指针和字符串的长度。这使得它在函数传参和返回值时非常高效。
与现有字符串类型的兼容性： std::string_view 可以方便地从 const char* 和 std::string 构造，也可以转换为 std::string，这使得它能够很好地融入现有的代码库。

`std::string_view` 的使用方法

接下来，咱们通过一些代码示例，来了解一下 std::string_view 的具体用法。

1. 从 `std::string` 构造 `std::string_view`

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

int main() {
    std::string str = "Hello, string_view!";
    std::string_view view(str);

    std::cout << "原始字符串: " << str << std::endl;
    std::cout << "string_view: " << view << std::endl;

    return 0;
}

在这个例子中，我们首先创建了一个 std::string 对象 str，然后使用它来构造一个 std::string_view 对象 view。注意，view 并不拥有 str 的数据，它只是指向 str 的数据。因此，即使 str 的内容发生变化，view 也会同步更新（只要 str 的内存没有被释放）。

2. 从 `const char*` 构造 `std::string_view`

#include <iostream>
#include <string_view>

int main() {
    const char* c_str = "Hello, const char*!";
    std::string_view view(c_str);

    std::cout << "原始字符串: " << c_str << std::endl;
    std::cout << "string_view: " << view << std::endl;

    return 0;
}

这个例子展示了如何从 C 风格字符串（const char*）构造 std::string_view。同样，view 并不拥有 c_str 的数据，它只是指向 c_str 的数据。

3. 使用 `std::string_view` 的成员函数

std::string_view 提供了丰富的成员函数，用于访问和操作字符串。这些函数都非常高效，因为它们不会进行字符串拷贝。

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

int main() {
    std::string str = "Hello, string_view!";
    std::string_view view(str);

    std::cout << "长度: " << view.length() << std::endl;          // 19
    std::cout << "大小: " << view.size() << std::endl;            // 19
    std::cout << "字符 at(0): " << view.at(0) << std::endl;        // H
    std::cout << "字符 []: " << view[0] << std::endl;             // H
    std::cout << "子串 substr(7, 6): " << view.substr(7, 6) << std::endl; // string
    std::cout << "前缀 starts_with(Hello): " << view.starts_with("Hello") << std::endl; // 1
    std::cout << "后缀 ends_with(view!): " << view.ends_with("view!") << std::endl;  // 1
    std::cout << "查找 find(string): " << view.find("string") << std::endl;    // 7

    return 0;
}

这些成员函数包括：

length() 和 size()：返回字符串的长度。
at(index) 和 operator[]：访问字符串的某个字符。
substr(pos, len)：返回字符串的子串。
starts_with(str) 和 ends_with(str)：检查字符串是否以某个前缀或后缀开始或结束。
find(str)：查找子串在字符串中的位置。
等等，还有很多其他的函数，可以参考 C++ 标准库的文档。

4. `std::string_view` 在函数传参中的应用

std::string_view 最常用的场景之一就是函数传参。使用 std::string_view 作为函数参数，可以避免不必要的字符串拷贝，提高性能。

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

void processString(std::string_view str_view) {
    std::cout << "处理字符串: " << str_view << std::endl;
    // ... 对 str_view 进行处理，例如查找、替换等，无需拷贝字符串
}

int main() {
    std::string str = "Hello, string_view in function!";
    processString(str);

    return 0;
}

在这个例子中，processString 函数接受一个 std::string_view 类型的参数。当调用 processString(str) 时，并不会发生字符串拷贝，而是直接传递 str 的视图。这大大提高了效率。

5. 与 `const char*` 和 `std::string` 的互操作性

std::string_view 与 const char* 和 std::string 之间可以方便地转换，这使得它能够很好地融入现有的代码库。

从 const char* 或 std::string 构造 std::string_view： 前面已经演示过了，很简单。
将 std::string_view 转换为 std::string： 使用 std::string(str_view) 即可。
将 std::string_view 转换为 const char*： 使用 str_view.data() 即可，但要注意，data() 返回的指针的生命周期与 str_view 相同，如果 str_view 被销毁，该指针将变为悬挂指针。

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

int main() {
    std::string str = "Hello, string_view!";
    std::string_view view(str);

    // 将 string_view 转换为 string
    std::string str2(view);
    std::cout << "string2: " << str2 << std::endl;

    // 将 string_view 转换为 const char*
    const char* c_str = view.data();
    std::cout << "c_str: " << c_str << std::endl;

    return 0;
}

`std::string_view` 的优势

std::string_view 最大的优势在于性能。它避免了不必要的字符串拷贝，尤其是在只读场景下，可以显著提高程序的效率。下面咱们来对比一下，看看 std::string_view 和其他字符串处理方式的性能差异。

1. 性能对比：拷贝 vs. 视图

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

// 使用 std::string 进行拷贝
void processStringCopy(const std::string& str) {
    // 模拟一些耗时操作
    for (size_t i = 0; i < 1000; ++i) {
        std::string temp = str;
    }
}

// 使用 std::string_view 进行处理
void processStringView(std::string_view str_view) {
    // 模拟一些耗时操作
    for (size_t i = 0; i < 1000; ++i) {
        std::string_view temp = str_view;
    }
}

int main() {
    std::string str = "This is a long string for performance test.";

    // 测试 std::string 的性能
    auto start = std::chrono::high_resolution_clock::now();
    processStringCopy(str);
    auto end = std::chrono::high_resolution_clock::now();
    auto duration_copy = std::chrono::duration_cast<std::chrono::microseconds>(end - start);

    // 测试 std::string_view 的性能
    start = std::chrono::high_resolution_clock::now();
    processStringView(str);
    end = std::chrono::high_resolution_clock::now();
    auto duration_view = std::chrono::duration_cast<std::chrono::microseconds>(end - start);

    std::cout << "std::string 耗时: " << duration_copy.count() << " 微秒" << std::endl;
    std::cout << "std::string_view 耗时: " << duration_view.count() << " 微秒" << std::endl;

    return 0;
}

在这个例子中，我们分别使用 std::string 和 std::string_view 来处理字符串，并测试了它们的运行时间。通常情况下，std::string_view 的运行时间会比 std::string 短很多，因为 std::string_view 避免了字符串拷贝。当然，实际的性能差异取决于具体的场景和字符串的长度，但一般来说，使用 std::string_view 能够带来显著的性能提升。

2. 在只读场景下的高效性

std::string_view 在只读场景下表现得尤为出色。例如，在解析配置文件、HTTP 请求头、JSON 数据等场景中，通常只需要读取字符串的内容，而不需要修改。在这种情况下，使用 std::string_view 可以避免不必要的拷贝，提高程序的性能。

例如，假设你正在编写一个 HTTP 服务器，需要解析客户端发送的请求头。请求头通常包含很多字符串，如 Host、User-Agent 等。使用 std::string_view 来处理这些请求头，可以避免对每个请求头进行拷贝，提高服务器的吞吐量。

3. 代码简洁性

除了性能之外，std::string_view 还可以使代码更简洁易懂。例如，在函数传参时，使用 std::string_view 可以减少函数参数的复杂性，提高代码的可读性。

`std::string_view` 的注意事项

虽然 std::string_view 带来了很多好处，但使用它时也需要注意一些问题，避免出现潜在的 bug。

1. 生命周期管理

std::string_view 并不拥有字符串数据，它只是一个视图。因此，在使用 std::string_view 时，需要特别注意字符串的生命周期。确保 std::string_view 指向的字符串数据在 std::string_view 的生命周期内是有效的，否则就会出现悬挂指针，导致未定义行为。

例如，下面的代码是错误的：

#include <iostream>
#include <string_view>

std::string_view getStringView() {
    std::string str = "This is a temporary string.";
    return std::string_view(str);
}

int main() {
    std::string_view view = getStringView(); // view 成为悬挂指针
    std::cout << view << std::endl; // 可能会导致程序崩溃或输出垃圾数据
    return 0;
}

在这个例子中，getStringView 函数返回了一个 std::string_view，但它指向的字符串 str 是在函数内部创建的，函数结束后 str 就会被销毁。因此，main 函数中获得的 view 就变成了一个悬挂指针，后续的操作就会导致问题。

正确的做法是，确保 std::string_view 指向的字符串数据的生命周期比 std::string_view 长。例如，可以这样修改代码：

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

std::string getString() {
    return "This is a temporary string.";
}

std::string_view getStringView() {
    std::string str = getString();
    return std::string_view(str);
}

int main() {
    std::string_view view = getStringView(); // view 指向 str 的数据
    std::cout << view << std::endl; // 正常输出
    return 0;
}

在这个例子中，getStringView 函数返回的 std::string_view 指向的是在 getStringView 函数内部创建的 str 的数据。因为在getStringView函数中str会被创建，所以返回的 std::string_view 指向的字符串的生命周期是安全的。

2. 避免修改原始字符串

std::string_view 本身是只读的，不能修改原始字符串的内容。如果需要修改，需要先将 std::string_view 转换为 std::string。

例如，下面的代码是错误的：

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

int main() {
    std::string str = "Hello, string_view!";
    std::string_view view(str);
    view[0] = 'h'; // 编译错误，不能修改 string_view
    std::cout << view << std::endl;
    return 0;
}

在这个例子中，我们尝试通过 std::string_view 修改原始字符串的第一个字符，但这会导致编译错误，因为 std::string_view 是只读的。正确的做法是，先将 std::string_view 转换为 std::string，然后再修改：

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

int main() {
    std::string str = "Hello, string_view!";
    std::string_view view(str);
    std::string str2(view);
    str2[0] = 'h'; // 修改 str2
    std::cout << str2 << std::endl; // 输出 hello, string_view!
    return 0;
}

3. 谨慎使用 `data()`

std::string_view 提供了 data() 方法，用于获取指向字符串数据的 const char* 指针。在使用 data() 时，也需要注意字符串的生命周期，确保该指针的生命周期与 std::string_view 相同，否则就会出现悬挂指针。

例如，下面的代码是错误的：

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

const char* getStringData() {
    std::string str = "This is a temporary string.";
    std::string_view view(str);
    return view.data(); // 返回的指针指向 str 的数据，str 在函数结束后被销毁
}

int main() {
    const char* data = getStringData(); // data 成为悬挂指针
    std::cout << data << std::endl; // 可能会导致程序崩溃或输出垃圾数据
    return 0;
}

在这个例子中，getStringData 函数返回了一个 const char* 指针，它指向的是 str 的数据。由于 str 是在函数内部创建的，函数结束后就会被销毁。因此，main 函数中获得的 data 就变成了一个悬挂指针，后续的操作就会导致问题。

正确的做法是，确保 data() 返回的指针指向的字符串数据的生命周期比 std::string_view 长。例如，可以这样修改代码：

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

std::string getString() {
    return "This is a temporary string.";
}

const char* getStringData() {
    std::string str = getString();
    std::string_view view(str);
    return view.data();
}

int main() {
    const char* data = getStringData(); // data 指向 str 的数据
    std::cout << data << std::endl; // 正常输出
    return 0;
}

总结

std::string_view 是 C++17 引入的一个非常有用的工具，它可以帮助我们更高效地处理字符串。它通过提供一个非拥有的、只读的字符串视图，避免了不必要的字符串拷贝，从而提高了程序的性能。在使用 std::string_view 时，需要注意字符串的生命周期，确保 std::string_view 指向的字符串数据是有效的。

总而言之，std::string_view 是一种非常优秀的字符串处理方式，在只读场景下，特别是在需要高性能的场景下，强烈推荐使用。希望今天的分享能够帮助大家更好地理解和使用 std::string_view，让你的 C++ 代码更高效、更简洁！

C++ 字符串处理新纪元：std::string_view 的应用与性能优化

为什么我们需要 `std::string_view`？

`std::string_view` 是什么？

`std::string_view` 的使用方法

1. 从 `std::string` 构造 `std::string_view`

2. 从 `const char*` 构造 `std::string_view`

3. 使用 `std::string_view` 的成员函数

4. `std::string_view` 在函数传参中的应用

5. 与 `const char*` 和 `std::string` 的互操作性

`std::string_view` 的优势

1. 性能对比：拷贝 vs. 视图

2. 在只读场景下的高效性

3. 代码简洁性

`std::string_view` 的注意事项

1. 生命周期管理

2. 避免修改原始字符串

3. 谨慎使用 `data()`

总结

延伸阅读

评论点评

C++ 字符串处理新纪元：std::string_view 的应用与性能优化

为什么我们需要 std::string_view？

std::string_view 是什么？

std::string_view 的使用方法

1. 从 std::string 构造 std::string_view

2. 从 const char* 构造 std::string_view

3. 使用 std::string_view 的成员函数

4. std::string_view 在函数传参中的应用

5. 与 const char* 和 std::string 的互操作性

std::string_view 的优势

1. 性能对比：拷贝 vs. 视图

2. 在只读场景下的高效性

3. 代码简洁性

std::string_view 的注意事项

1. 生命周期管理

2. 避免修改原始字符串

3. 谨慎使用 data()

总结

延伸阅读

评论点评

为什么我们需要 `std::string_view`？

`std::string_view` 是什么？

`std::string_view` 的使用方法

1. 从 `std::string` 构造 `std::string_view`

2. 从 `const char*` 构造 `std::string_view`

3. 使用 `std::string_view` 的成员函数

4. `std::string_view` 在函数传参中的应用

5. 与 `const char*` 和 `std::string` 的互操作性

`std::string_view` 的优势

`std::string_view` 的注意事项

3. 谨慎使用 `data()`