我阅读了迭代字符串单词的最优雅的方式，并喜欢答案的简洁性。现在我想对 string_view 做同样的事情。问题是，stringstream不能采取string_view：

#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
#include <iterator>

int main() {
    using namespace std;
    string_view sentence = "And I feel fine...";
    istringstream iss(sentence); // <== error
    copy(istream_iterator<string_view>(iss),
         istream_iterator<string_view>(),
         ostream_iterator<string_view>(cout, "\n"));
}

那么有没有办法做到这一点呢？如果不是，那么为什么这样的事情不符合惯用语呢？

试图提供解决方案的std ::性病string_view和的std :: string :: unordered_set,我与更换玩弄std::unordered_set<std::string>与std::unordered_map<std::string_view, std::unique_ptr<std::string>>(该值std::unique_ptr<std::string>,因为小串的优化将意味着该地址string的底层数据并不总是被转移std::move.

我的原始测试代码似乎有用(省略标题):

using namespace std::literals;

int main(int argc, char **argv) {
    std::unordered_map<std::string_view, std::unique_ptr<std::string>> mymap;

    for (int i = 1; i < argc; ++i) {
        auto to_insert = std::make_unique<std::string>(argv[i]);

        mymap.try_emplace(*to_insert, std::move(to_insert));
    }

    for (auto&& entry : mymap) {
        std::cout << entry.first << ": " << entry.second << std::endl;
    }

    std::cout << std::boolalpha << "\"this\" in map? " << (mymap.count("this") == 1) << std::endl; …

我看到string_view和string都有对称运算符==,对于字符串,它有构造函数接受string_view和运算符将自身转换为string_view.所以当我们尝试在string_view和string之间使用operator == compare时,它应该是不明确的吗？

我认为我的想法一定有问题.请提前告知我,谢谢!

例:

std::string s1 = "123";
std::string_view s2 = "123";
// in the following comparison, will s1 use the convert operator to generate a string_view, or will s2 use string's string_view constructor to generate a string?
if (s1 == s2) {...}

据我所知，gsl::string_span并std::string_view似乎有本质上使用的同一个道理。真的是这样吗？如果是这样，它们实际上是否相同？如果不是 - 它们有什么不同？

相关问题：`gsl::string_span` 的目的是什么？

介绍

我正在编写一些通信应用程序。在 C++17（没有 Boost）之前，我使用std::string它的 const 引用作为cls1.

从 C++17 开始，我将std::string_view代码引入为cls2. 但是，我没有明确的政策何时应该使用std::string_view. 我的通信应用程序从网络接收数据并将其存储到recv_buffer. 并从recv_buffer.

建造

如果我只关注cls1的构造函数，移动构造是有效的。但我认为参数s来自哪里。如果它最初来自recv_buffer，我可以std::string_view在接收（很早）点创建。并且在recv_buffer的生命周期内启用，std::string_view随处使用。如果我需要存储部分recv_buffer然后创建std::string.

我注意到的唯一例外recv_buffer是始终包含我的应用程序类的完整数据。在这种情况下，移动构造是有效的。

吸气剂

我认为使用返回类型std::string_view具有优势。一些成员函数如是substr()高效的。但到目前为止，我没有看到任何缺点。

题

我怀疑我可能只看到std::string_view. 在重新编写许多代码之前，我想知道您的想法。

验证码

#include <string>

struct cls1 {
    explicit cls1(std::string s):s_(std::move(s)) {}
    std::string const& get() const { return s_; }
private:
    std::string s_;
}; …

还是我在测量别的东西？

在这段代码中，我有一堆标签 ( integers)。每个标签都有一个字符串表示（const char*或std::string_view）。在循环堆栈值被转换为相应的字符串值。这些值附加到预先分配的字符串或分配给数组元素。

结果表明，带有std::string_view的版本比带有 的版本稍快const char*。

代码：

#include <array>
#include <iostream>
#include <chrono>
#include <stack>
#include <string_view>

using namespace std;

int main()
{
    enum Tag : int { TAG_A, TAG_B, TAG_C, TAG_D, TAG_E, TAG_F };
    constexpr const char* tag_value[] = 
        { "AAA", "BBB", "CCC", "DDD", "EEE", "FFF" };
    constexpr std::string_view tag_values[] =
        { "AAA", "BBB", "CCC", "DDD", "EEE", "FFF" };

    const size_t iterations = 10000;
    std::stack<Tag> stack_tag;
    std::string out; …

我有一个相对简单的用例：我想将一个特征关联到一个类，该类将返回一些用户定义的字符串，即一些用户定义的注册 ID。由于这个注册应该在编译时定义，我希望它是 constexpr，所以我写了如下内容：

template <typename T>
struct ClassRegistration
{
    static constexpr std::string_view
    Name();
};

template <>                                                                                    
struct ClassRegistration<int>                                                            
{                                                                                              
    static constexpr std::string_view                                                        
    Name()                                                                                     
    {                                                                                          
        return std::string_view{ "int" };                                                     
    }                                                                                          
};

https://godbolt.org/z/5p8xkA

一切正常，但由于 string_view 实际上并不拥有它的缓冲区，我想知道它是否保证安全，我不只是指一个悬空指针。从我读到的字符串文字保证具有与程序本身一样长的生命周期（从这个函数返回的字符串文字的SO Lifetime）。

因此，string_view 的这种用法是否安全合适？

我有一个问题，因为我不清楚函数参数何时被销毁。因此，以下 doSomething 函数的串联是否容易出错？

我问是因为“程序员有责任确保 std::string_view 的寿命不会超过指向的字符数组”。在特定情况下可以保证吗？

#include <string>
#include <string_view>

std::string doSomething(const std::string_view& str_view)
{
    // do something and create a new std::string instance based on the std::string_view instance

    return str;
}

int main()
{
    std::string input_str{"Hello world!"};

    std::string output_str{ doSomething(doSomething(doSomething(input_str))) };

    return 0;
}

cppreference使用它来描述 std::string_view：

• std::basic_string_view(C++17) -对字符串子序列的轻量级非拥有只读视图。

devtut 和 sodocumentation 也 使用它来描述 std::string_view ：

C++17 引入了std::string_view，它只是一个非拥有范围的 const chars，可实现为一对指针或一个指针和一个长度。

和这里的各种其他问题和答案参考它，但我找不到它的含义的任何解释。

可以很容易地std::string_view从 a创建一个std::string。但是如果我想创建一个范围的字符串视图，std::string使用迭代器是std::string行不通的。

这是我尝试过的代码：https : //gcc.godbolt.org/z/xrodd8PMq

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

int main()
{
    std::string str{"My String"};
    std::string_view strView{str};  // works
    //std::string_view strSubView{str.begin(), str.begin() + 2}; // error
}

当然，也许我们可以将子字符串制作出来str并用于制作字符串视图strSubView，但是还有一个额外的字符串创建。

我发现std::basic_string_view第 5 个构造函数采用迭代器的范围。

template<class It, class End>
constexpr basic_string_view(It first, End last);

但它仅仅是std::stringor std::basic_string_view本身的迭代器吗？如果不是 forstd::string迭代为什么我们不应该有一个，毕竟是字符串视图：

描述了一个对象，它可以引用一个常量连续的类似字符的对象序列！

取char连续序列的范围，不应该算吗？