Dfyjkt

According to cppreference.com, when a const std::string is constructed from an input const char* (e.g. const std::string("some literal");), a copy of the C string is stored in the std::string.

I'm trying to understand if (and why) the copy is required specifically in the case where the input C string is a string literal. I would think that the std::string could simply refer to the string literal instead of creating a copy, so that the following code would only create "some literal" once.

std::string str1("some literal");
std::string str2("some literal");

Certainly, performing a copy for C strings that aren't string literals is wise, because it allows the std::string to manage the lifetime of the data that it refers to. However, this is not an issue for string literals because they exist for the lifetime of the program.

Also, since we are talking about const strings, we don't need to worry about the underlying data being changed during the program and breaking the value semantics of the std::strings. Well, at least as long as const_cast isn't used, but using const_cast is asking for trouble anyway, so I'm not too worried about that case.

So, is there any reason why the compiler can't optimize this case to have const std::strings refer to const char*s instead of creating copies? Alternatively, if the cppreference link was incorrect, and this optimization actually is implemented by some compilers, which compilers support this?

For the sake of this question, let's assume that the string literal is long enough that the small string optimization won't be a factor.

In your example, a std::string simply receives a pointer, it has no way of know what kind of memory that pointer is actually pointing at.

The fact that the pointer is declared as pointing to const data is not relevant. A pointer to non-const data can be assigned to a pointer to const data (creating read-only access to otherwise writable data).

The std::string simply has no way of knowing that the pointer it is given is pointing at a string literal. The pointer could just as easily be pointing at an array on the call stack, or to a memory block allocated with new, or to memory owned by an external library.

There is nothing special about a narrow string literal, it is not some magic type that std::string could adjust its behavior for. It is just a plain ordinary const char, just one whose memory is setup by the compiler/linker. It decays to const char *.

So std::string does the only sane and safe thing it can do given the lack of origin info - make a copy of the data.

That also keeps the implementation simple - the std::string always owns the data it holds.

If you want a string-like container that doesn't own the data, just points at it, then look at C++17's std::string_view, or boost::string view for earlier compilers.