string_view behaviour when passing temporary std::string

问题

I just ran into some misunderstanding: at least in libc++ implementation std::experimental::string_view has the following concise implementation:

template <class _CharT, class _Traits....>
class basic_string_view {
public:
   typedef _CharT value_type;
   ...
   template <class _Allocator>
   basic_string_view(const basic_string<_CharT, _Traits, _Allocator>& str):
       __data(str.data()), __size(str.size())
   {
   }

private:
   const value_type* __data;
   size_type __size;
};

Does this implementation imply that if we pass rvalue expression to this constructor, we will get undefined behaviour when using __data after construction?

回答1:

That's right. A string_view is a non-owning wrapper with reference semantics that must only be used when the referred string outlives the use of the view.

The typical use case is in function parameters where the actual string lives for the duration of the function call and the function body never stores the view, but only reads it:

void foo(std::experimental::string_view message)  // pass by value
{
    std::cout << "You said, '" << message << "'.\n";
}

Usage:

foo("Hello");       // OK, string literal has static storage
foo(s);             // OK, s is alive
foo(s.substr(1));   // OK, temporary lives until end of full-expression

The moral is: If you only need the string for the duration of the function body, give the function a string_view parameter, and it can uniformly bind to any kind of stringoid argument. You don't need a function template, copying string_views is cheap, and you get some neat substringing operations for free. By contrast, never store a string_view, but always store astring:

struct X
{
    X(std::experimental::string_view s) : s_(s) {}

    std::string s_;     // NEVER have a string_view class member!
};

来源：https://stackoverflow.com/questions/26978266/string-view-behaviour-when-passing-temporary-stdstring

标签

c++

string

c++11

fundamentals-ts

string-view