Why does the string introduced by the sv suffix not expire?

Question

It is a common mistake to initialize a std::string_view with a temporary std::string.

using namespace std::literals;

std::string_view sv1 = "foo" ; // good
std::string_view sv2 = "bar"s; // bad: "foo"s will expire

std::cout << sv1 << "\n"       // outputs foo
          << sv2 << "\n";      // undefined behavior

That's because "bar"s, the temporary std::string, is destroyed at the end of the full-expression.

But how about "foo"sv?

std::string_view sv3 = "baz"sv;

Of course this should work, because the suffix sv is otherwise useless. But how is this fundamentally different from "baz"s? In other words, why does the string introduced by "baz"sv not expire?

Answer 1

Why the declaration of sv2 is bad

Per [basic.string.literals]/1:

string operator""s(const char* str, size_t len);

Returns: string{str, len}.

In "foo"s, the string literal "foo" is used to initialize a temporary std::string. The characters are copied to the underlying array of the temporary std::string. std::string_view is a non-owning view, and sv2 points to the underlying array of the temporary std::string. After the temporary std::string is destroyed, sv2 keeps pointing to the (now expired) underlying array, and trying to output sv2 results in undefined behavior.

Why the declaration of sv3 is good

Per [string.view.literals]/1:

constexpr string_view operator""sv(const char* str, size_t len) noexcept;

Returns: string_­view{str, len}.

Therefore, the declaration of sv3 is equivalent to:¹

std::string_view sv3{"baz", 3};

sv3 directly points to the string literal "baz". A string literal has static storage duration and does not expire.

¹ There is some subtlety here. Copy elision may or may not apply here. Since string_views are non-owning, copying string_views does not introduce new temporary strings. Therefore, regardless of whether a copy is to take place, the state of sv3 is the same.