std::string_view

原创 已于 2024-05-19 20:50:46 修改 · 385 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #string_view

于 2024-03-28 22:43:02 首次发布
文章介绍了如何在C++中优先使用std::string_view作为函数参数以提高代码效率和兼容性，避免了因传入不同类型的参数（如constchar*和std::string）而可能产生的额外对象构造。同时强调了std::string_view的内存安全特性及其与std::string的不同之处，以及在实际示例中的应用和注意事项。

1. 可优先使用std::string_view作为函数入参

如下的代码，当只提供入参是std::string的版本时，当传入const char*时会构造一个std::string对象。

#include <iostream>
#include <format>
#include <string>
#include <string_view>
#include <iomanip>

void print(const std::string& str){
    std::cout << "**version1**, " << __func__ << ", " << str << std::endl;
}

/*void print(const char* str){
    std::cout << "--version2--, " << __func__ << ", " << str << std::endl;
}

void print(const std::string_view str){
    std::cout << "==version3==, " << __func__ << ", " << str << std::endl;
}*/

auto main()->int{
    const char* ch = "const char*";
    std::string str("std::string");
    print(ch);   // **version1**, print, const char*
    print(str);  // **version1**, print, std::string
}

可以提供重载的print来避免上述问题，不过会增加代码量。

#include <iostream>
#include <format>
#include <string>
#include <string_view>
#include <iomanip>

void print(const std::string& str){
    std::cout << "**version1**, " << __func__ << ", " << str << std::endl;
}

void print(const char* str){
    std::cout << "--version2--, " << __func__ << ", " << str << std::endl;
}

/*void print(const std::string_view str){
    std::cout << "==version3==, " << __func__ << ", " << str << std::endl;
}*/

auto main()->int{
    const char* ch = "const char*";
    std::string str("std::string");
    print(ch);   // --version2--, print, const char*
    print(str);  // **version1**, print, std::string
}

而使用std::string_view作为入参可以同时兼容入参是std::string和const char*的情况。

#include <iostream>
#include <format>
#include <string>
#include <string_view>
#include <iomanip>

/*void print(const std::string& str){
    std::cout << "**version1**, " << __func__ << ", " << str << std::endl;
}

void print(const char* str){
    std::cout << "--version2--, " << __func__ << ", " << str << std::endl;
}*/

void print(const std::string_view str){
    std::cout << "==version3==, " << __func__ << ", " << str << std::endl;
}

auto main()->int{
    const char* ch = "const char*";
    std::string str("std::string");
    print(ch);   // ==version3==, print, const char*
    print(str);  // ==version3==, print, std::string
}

但是当三个版本的print都提供时编译器还是会进行最佳匹配。

#include <iostream>
#include <format>
#include <string>
#include <string_view>
#include <iomanip>

void print(const std::string& str){
    std::cout << "**version1**, " << __func__ << ", " << str << std::endl;
}

void print(const char* str){
    std::cout << "--version2--, " << __func__ << ", " << str << std::endl;
}

void print(const std::string_view str){
    std::cout << "==version3==, " << __func__ << ", " << str << std::endl;
}

auto main()->int{
    const char* ch = "const char*";
    std::string str("std::string");
    print(ch);   // --version2--, print, const char*
    print(str);  // **version1**, print, std::string
}

2. std::string_view使用示例

2.1 示例一

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

std::string generateGreeting(std::string_view name){
    std::string result("Hello ");
    result += name;
    result.append("!");
    return result;
}

auto main()->int{
    //using namespace std::literals;
    using namespace std::literals::string_literals;
    using namespace std::literals::string_view_literals;

    std::cout << generateGreeting("World") << std::endl;     // 实参是const char*
    std::cout << generateGreeting("World"s) << std::endl;    // 实参是std::string(通过const char*及std::string operator""s构造)
    std::cout << generateGreeting("World"sv) << std::endl;   // 实参是std::string_view(通过const char*及constexpr std::string_view operator""sv构造)
}

输出：

Hello World!
Hello World!
Hello World!

2.2 示例二

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

auto main()->int{
    const char* name = "TARANIS";
    std::cout << name << std::endl;          // TARANIS
    std::cout << (void*)name << std::endl;   // 0x402011

    using namespace std::literals::string_literals;
    using namespace std::literals::string_view_literals;

    std::cout << (void*)("Hello World!"sv.data()) << std::endl;  // 0x402004
}

2.3 示例三

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

auto main()->int{
    using namespace std::literals::string_view_literals;
    std::string_view fruit("banana"sv);
    size_t origin_size = fruit.size();

    std::cout << std::format("{0:>{1}}", fruit, origin_size) << "'s address = " << (void*)fruit.data() << std::endl;
    fruit.remove_prefix(1);
    std::cout << std::format("{0:>{1}}", fruit, origin_size) << "'s address = " <<  (void*)fruit.data() << std::endl;
    fruit.remove_prefix(1);
    std::cout << std::format("{0:>{1}}", fruit, origin_size) << "'s address = " <<  (void*)fruit.data() << std::endl;
    fruit.remove_prefix(1);
    std::cout << std::format("{0:>{1}}", fruit, origin_size) << "'s address = " <<  (void*)fruit.data() << std::endl;
}

上面这段代码的输出可能是：

banana's address = 0x403019
 anana's address = 0x40301a
  nana's address = 0x40301b
   ana's address = 0x40301c

由输出的地址可知视图fruit观察👀的对象并没有变，只是起始地址逐渐加1。

2.4 示例四

std::string_view与std::string对比。

2.4.1 std::string_view的示例

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

auto main()->int{
    using namespace std::literals::string_view_literals;
    std::string_view fruit("banana"sv);
    size_t origin_size = fruit.size();

    std::cout << std::format("{0:>{1}}", fruit, origin_size) << "'s address = " << (void*)fruit.data() << std::endl;
    auto sub = fruit.substr(2,4);
    std::cout << std::format("{0:>{1}}", sub, origin_size) << "'s address = " <<  (void*)sub.data() << std::endl;
}

上面这段代码的输出可能是：

banana's address = 0x4151d2
  nana's address = 0x4151d4

由输出的地址可知视图fruit观察👀的对象并没有变，只是起始地址加了2（因为substr是从2开始的）。

2.4.1 std::string的示例

#include <iostream>
#include <string>
#include <format>

auto main()->int{

    using namespace std::literals::string_literals;
    std::string fruit("banana"s);
    size_t origin_size = fruit.size();

    std::cout << std::format("{0:>{1}}", fruit, origin_size) << "'s address = " << (void*)fruit.data() << std::endl;
    auto sub = fruit.substr(1);
    std::cout << std::format("{0:>{1}}", sub, origin_size) << "'s address = " <<  (void*)sub.data() << std::endl;
}

上面这段代码的输出可能是：

banana's address = 0x7fff682b5650
 anana's address = 0x7fff682b5620

输出的地址差异较大，所以对于std::string来说调用substr是构造了一个新的std::string。

2.5 不可通过下标的方式修改std::string_view

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

int main(){
    using namespace std::literals::string_literals;
    using namespace std::literals::string_view_literals;

    std::string_view view = "Hello World."sv;
    std::string str = "Hello World."s;

    str[2] = '5';     // OK
    //view[2] = '5';  // 编译报错，error: assignment of read-only location 'view.std::basic_string_view<char>::operator[](2)'
}

3. 务必注意std::string_view并不拥有数据

std::string_view并不拥有数据，因此使用std::string_view期间一定要注意其引用的对象是否有效。

3.1 错误示例一

// g++  main.cpp  -std=c++20  -fsanitize=address
#include <iostream>
#include <string>
#include <string_view>

auto main()->int{
    using namespace std::literals::string_literals;
    using namespace std::literals::string_view_literals;

    std::string_view str_v;
    {
        std::string str("abcdefg"s);
        str_v = str;
    }  // 此处str已经析构了，使用str_v属于未定义行为了
    std::cout << str_v << std::endl;
}

上述代码编译后，运行报错如下：

=================================================================
==1==ERROR: AddressSanitizer: stack-use-after-scope on address 0x7409c2d00050 at pc 0x7409c52bb971 bp 0x7ffeff503c60 sp 0x7ffeff503420
READ of size 7 at 0x7409c2d00050 thread T0
    #0 0x7409c52bb970  (/opt/compiler-explorer/gcc-13.2.0/lib64/libasan.so.8+0x6b970) (BuildId: 53df075b42b04e0fd573977feeb6ac6e330cfaaa)
    #1 0x7409c5132d8c in std::basic_ostream<char, std::char_traits<char> >& std::__ostream_insert<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*, long) (/opt/compiler-explorer/gcc-13.2.0/lib64/libstdc++.so.6+0x144d8c) (BuildId: 925fdbb642c48958ee86b4c067db1fd9baa5e4d8)
    #2 0x403533 in std::basic_ostream<char, std::char_traits<char> >& std::operator<< <char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, std::basic_string_view<char, std::char_traits<char> >) /opt/compiler-explorer/gcc-13.2.0/include/c++/13.2.0/string_view:762
    #3 0x4024b6 in main /app/example.cpp:31
    #4 0x7409c4c29d8f  (/lib/x86_64-linux-gnu/libc.so.6+0x29d8f) (BuildId: 962015aa9d133c6cbcfb31ec300596d7f44d3348)
    #5 0x7409c4c29e3f in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x29e3f) (BuildId: 962015aa9d133c6cbcfb31ec300596d7f44d3348)
    #6 0x402214 in _start (/app/output.s+0x402214) (BuildId: 4e4307113b24ee741da51d08913a90cf1c20cea4)

Address 0x7409c2d00050 is located in stack of thread T0 at offset 80 in frame
    #0 0x4022e5 in main /app/example.cpp:22

  This frame has 2 object(s):
    [32, 48) 'str_v' (line 26)
    [64, 96) 'str' (line 28) <== Memory access at offset 80 is inside this variable
HINT: this may be a false positive if your program uses some custom stack unwind mechanism, swapcontext or vfork
      (longjmp and C++ exceptions *are* supported)
SUMMARY: AddressSanitizer: stack-use-after-scope (/opt/compiler-explorer/gcc-13.2.0/lib64/libasan.so.8+0x6b970) (BuildId: 53df075b42b04e0fd573977feeb6ac6e330cfaaa) 
Shadow bytes around the buggy address:
  0x7409c2cffd80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  0x7409c2cffe00: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  0x7409c2cffe80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  0x7409c2cfff00: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  0x7409c2cfff80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
=>0x7409c2d00000: f1 f1 f1 f1 00 00 f2 f2 f8 f8[f8]f8 f3 f3 f3 f3
  0x7409c2d00080: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  0x7409c2d00100: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  0x7409c2d00180: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  0x7409c2d00200: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  0x7409c2d00280: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
Shadow byte legend (one shadow byte represents 8 application bytes):
  Addressable:           00
  Partially addressable: 01 02 03 04 05 06 07 
  Heap left redzone:       fa
  Freed heap region:       fd
  Stack left redzone:      f1
  Stack mid redzone:       f2
  Stack right redzone:     f3
  Stack after return:      f5
  Stack use after scope:   f8
  Global redzone:          f9
  Global init order:       f6
  Poisoned by user:        f7
  Container overflow:      fc
  Array cookie:            ac
  Intra object redzone:    bb
  ASan internal:           fe
  Left alloca redzone:     ca
  Right alloca redzone:    cb
==1==ABORTING

3.2 错误示例二

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

auto main()->int{
    using namespace std::literals::string_literals;
    using namespace std::literals::string_view_literals;

    std::string_view str_v = "Hello World.";       // 没问题
    //std::string_view str_v = "Hello World."sv;   // 没问题

    /* 下面两句在给std::string_view赋值之后std::string临时对象就被析构了，再使用就是未定义行为 */
    //std::string_view str_v = std::string("Hello World.");   // ERROR: AddressSanitizer: stack-use-after-scope
    //std::string_view str_v = "Hello World."s;               // ERROR: AddressSanitizer: stack-use-after-scope

    std::cout << str_v << std::endl;
}
C++17完整导引-组件之std::string_view
西门吹雪
06-28 3170
在`C++17`中，`C++`标准库引入了一个特殊的字符串类：`std::string_view`
C++ std::string_view用法
mls805379973的博客
11-15 1202
是 C++17 中引入的一个非拥有（non-owning）字符串视图类，用于提供对字符串的轻量级、零开销的访问。它不拥有字符串的内存，而是引用已存在的字符串数据。可以用于代替或，提供更方便、安全和高效的字符串操作。
C++笔记：std::string_view
最新发布
ouliten的博客
11-24 570
是 C++17 引入的。它不拥有字符串，只是“指向一段连续字符”的二元组。避免创建临时、减少拷贝，提高性能。字面量并且。
[c++17标准库特性之新增STL特性] --- std::string_view
M2嵌入式
04-09 885
std::string_view 是 C++17 标准库中的一种新类型，它提供了对一个字符序列的非拥有式视图，该序列存储在 std::string 或字符数组中。它是 std::string 的一种轻量级替代方案，旨在避免字符串复制或分配的开销。以下是一些 std::string_view 的重要特性：非拥有式视图：std::string_view 不拥有底层的字符序列，它只是字符序列的引用。这意味着 std::string_view 的构造函数不会复制字符序列，而是指向它。
深度解读C++17中的std::string_view：解锁字符串处理的新境界
Lion_Long的博客
04-11 6650
std::string_view是C++17引入的一个非拥有的字符串视图类型，它提供了一种轻量级的方式来访问现有字符串数据。std::string_view通过避免字符串复制和内存分配，它可以显著提高程序性能，并提供方便的字符串处理能力。但是，在使用过程中需要注意正确管理原始字符串的生命周期，以确保使用的字符串数据有效和安全。
C++17 string_view 详细案例
qq_41540355的博客
05-21 2101
C++17 使用std::string_view来观测一段字符数组，减少内存的拷贝，或者说不至于像string对象通过移动后，前一个对象放弃那快本属于它的内存。 // 原码： // TYPEDEFS FOR basic_string_view using string_view = basic_string_view<char>; // CLASS TEMPLATE basic_string_view template <class _Elem, class _Traits> cl
C++17 使用 std::string_view避免字符串拷贝优化程序性能
12-16
C++中std::string是日常Coding中经常使用的一个类，使用起来非常方便，但是也存在一些弊端。 如下代码，参数传递的过程发生了内存分配(Memory Allocation)和内存拷贝。 void fun(const std::string& s) { std::...
C++编程：使用std::string仿写c++17的std::string_view
Where there is life, there is hope.
11-22 720
在性能敏感的应用中（如网络库、系统编程等），频繁的字符串拷贝会带来性能开销。 C++17 字符串string_view可以减少拷贝。本文介绍一个基于 C++11 实现的的 `StringView` 类，设计理念是避免不必要的内存分配和字符串拷贝，同时提供类似标准字符串的操作接口。
C++ `std::string_view`：C++17 字符串视图的零拷贝优化
weixin_41455464的博客
07-11 394
它就像一个拿着放大镜的侦探，可以让你“看到”字符串的内容，而不需要拷贝任何东西！今天咱们要聊的是一个C++17里加入的宝贝疙瘩，一个能让你的代码跑得更快、更省内存，而且还不用费劲心思去改代码的家伙——在C++的世界里，字符串一直是个让人又爱又恨的角色。我们离不开它，但它也经常给我们带来各种各样的问题：拷贝开销大，内存管理复杂，各种字符串类型之间的转换让人头疼等等。但是，在很多场景下，它可以帮助你避免不必要的拷贝，提高程序的性能。有很多优点，但使用它的时候也要小心，因为它只是一个“视图”，而不是拥有所有权。
深入理解 `std::string_view`：现代 C++ 中的高效字符串处理工具
软件开发领域最优质的博客
09-07 1331
本文深入探讨了C++17引入的std::string_view，重点分析其非拥有性、高效性和不可变性三大特性。文章对比了string_view与std::string、const char*的性能差异，详细介绍了其在函数参数传递、字符串分割等场景的典型用法，并强调了生命周期管理的重要性。作为现代C++的高效字符串处理工具，string_view能有效避免不必要的拷贝，但需注意其只读特性和数据依赖关系，合理使用才能发挥最大优势。
C++17新特性之std::string_view
大牛直播SDK
04-10 6159
std::string_view系C++17标准发布后新增的内容，类成员变量包含两个部分：字符串指针和字符串长度，相比std::string, std::string_view涵盖了std::string的所有只读接口。如果生成的std::string无需进行修改操作，可以把std::string转换为std::string_view，std::string_view记录了对应的字符串指针和偏移位置，无需管理内存，相对std::string拥有一份字符串拷贝，如字符串查找和拷贝，效率更高。 废话不多说，上
为什么C++17要引入std::string_view？
红军不怕远征难，万水千山只等闲
01-21 3664
std::string_view的优点：1）高效性：std:string_view主要用于提供字符串的视图(view)，使std::string_view拷贝字符串的过程非常高效，永远不会创建字符串的任何副本，不像std::string会效率低下且导致内存开销。std::string_view不拥有字符串数据，它仅提供对现有字符串的视图或引用(view or reference)。这使得它适合需要访问或处理字符串而无需内存分配或重新分配开销的场景，特别是在处理大量字符串时非常有用。
跟我学c++中级篇——STL字符串之std::string_view
fpcc的专栏
10-25 2203
一、标准库字符串处理 C和C++的一个很不一样的区别就是对字符串的处理，在c++的标准库里提供了一个std::string的字符串操作类。这使得c++对字符串的操作从某种程度上摆脱了原始指针的操作。从这个角度来说，对c++小白来说，肯定是利好的。但麻烦就在于c++强大的灵活性，导致在处理字符串时，效率会由于不同的应用编码导致差异性很大；同时，一不小心就有可能对原始字符串进行了修改，导致异常的发生。而这些，都不是一个普通菜鸟能够解决的。 当然，如果从一个完美的角度来看待这个问题，基本是无解的，毕竟c++的整体
C++中std::string和std::string_view使用详解和示例
qq_36812406的博客
07-24 1186
是 C++ 标准库提供的字符串类，封装了动态管理的字符数组，功能比传统的 C 风格字符串（char*）更强大、安全、易用。<string>std是一个非拥有型的只读字符串引用，不分配内存、不复制数据，适用于传参和高效处理子串。功能需求建议使用动态字符串、读写操作只读子串、传参跨平台 Unicode 处理utf8cpp或ICUUTF-16 / UTF-32 字符。
C++17中std::string_view的使用
网络资源是无限的
10-22 1867
C++17中std::string_view的使用
轻松理解c++17的string_view
性感的小君君
07-10 966
是一个高效的、不拥有的字符串视图类，设计用于提高字符串处理的性能和简便性。它在不复制字符串数据的情况下，提供了丰富的字符串操作接口，使得字符串处理更高效、代码更简洁。
C++ std::string_view介绍及性能提升分析
weixin_44126836的博客
04-14 1067
std::string_view作为一种轻量级的字符串处理工具，在只读场景下，特别是在需要高性能的场景下，具有显著的优势。它通过避免不必要的字符串拷贝，提高了程序的性能，同时保持了API的灵活性。在现代C++编程中，合理运用std::string_view，可以在确保性能的同时，提高程序的安全性和灵活性。
C++ string_view
doubleintfloat的博客
04-14 1060
是C++17引入的一个轻量级、非拥有的字符串视图类，定义于头文件中。它提供了一种高效且安全的方式来处理字符串数据，而无需复制字符串内容。以下是关于。
深入理解C++17中的std::string_view
sillyss的博客
04-30 1584
只读字符串参数传递解析和查看大型字符串高频字符串操作需要兼容多种字符串类型的接口正确使用时可以显著提升程序性能，但需要时刻注意其非拥有的特性。掌握的使用是现代C++高效字符串处理的关键技能。进一步学习《Effective Modern C++》条款15-17SL.str.11。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值