Why are string literals lvalues and not xvalues?

Question

Ben Saks in his lesson "Understanding Value Categories" at the 2019 CppCon in Aurora (CO) (great lesson btw) said:

"Character string literals, such as "examplestring", are lvalues because they are basically arrays and they need to be stored in memory."

At the end of the lesson a person ask this question to Ben: "Did you really mean that string literals are lvalues? because, if they are, why I can't assign to a string literal?" He answered "yes, because they act like array and they need a place in memory"

This confused me a little bit

So I have some questions:

1. If the only reason why string literals are lvalues is that, why they cannot be temporary rvalues? During that lesson he explained that if an rvalue is too big (such as very long integer literals) the compiler store that in memory but that doesn't mean that they are lvalues...

2. Why can I pass a string literal as a rvalue reference?

3. std::string a = "string1"+"string2"; if "string1" and "string2" are lvalues how their sum can be an rvalue?

There something that I have missed because, in conclusion, everything would have been right for me if he had said that string literals are xvalues because as array they must have a location in memory but they can't be lvalues because they don't have a "name" and I can't reach them in memory because I'm not able to know the address (ex: int a => &a if I want to reach it)

YouTube link for the lesson: https://youtu.be/XS2JddPq7GQ?si=5aCMj1sm4YKHMPW-

Thank you in advance for your answers.

Answer 1

Character string literals, such as "examplestring", are lvalues because they are basically arrays and they need to be stored in memory.

A string literal is an array of type char [N]. All arrays are non-modifiable lvalues. You can get their address simply by using their name (it decays to a pointer most contexts), but you can't use them on the left side of an assignment:

error: assignment to expression with array type
 "abc" = "def";
       ^

You will get a similar error when attempting this:

int arr1[10] = { ... };
int arr2[10] = { ... };
arr2 = arr1;

Besides the assignment operator, any of the rest of the operators requiring a modifiable lvalue will not work:

"abc"++;
arr1++;

Answer 2

Firstly, we should keep in mind that the reason why string literals are lvalues is that the C++ standard defines them to be lvalues. It is not the case that you can determine whether or not something is an lvalue purely by reasoning about its lifetime, the operations applicable to it, and so on. (And in fact C++ redefined some types of expressions as lvalues that had originally been rvalues in C, such as the result of the prefix increment operator. That does not mean that it had been "wrong" for them to be rvalues in C.)

Now the reason why it is sensible to define string literals to be lvalues and not xvalues is that xvalues are only produced in two ways in C++:

• when a temporary object is materialized (in this case, the xvalue refers to the just-materialized object, which is indeed expiring soon, like the name "xvalue" suggests), or
• when an expression is explicitly given type T&& (where T is some object type), i.e., a call to a function whose return type is T&&, or a cast to T&&.

But the array that a string literal refers to is not a temporary object, nor any soon-to-be-expiring object; it is an object with static storage duration, i.e., it will survive until the end of the program.

The built-in & operator can only be applied to lvalues. (As a special rule, a bit-field cannot be the operand of &, even if it's an lvalue.) Does it make sense to give a string literal a value category that allows & to be applied to it, or not? Arguably, it does, because of the permanency of the storage that they refer to.

But you cannot assign to a string literal because it is const. Being const doesn't make something any less of an lvalue.

Answer 3

About value categories of literals

First of all, lvalues are characterized by two properties:

• they have an identity (such as a name, or an expression that names them)
• they cannot be moved from (whereas xvalues can be moved from)

It wouldn't make any sense to be able to move from a string literal, since it's an array of of type const char[N]. Being able to move from a const object is meaningless.

Solely based on that, it doesn't make sense for them to be rvalues (i.e. xvalues or prvalues), because these categories imply movability.

It's worth noting that integer literals like 123 are prvalues, so they refer to a new unique object. String literals are different because they refer to an existing object somewhere in memory. It's possible in that in your program, all appearances of "string" refer to the same object, and &"string" == &"string" might be true.

See also Why are string literals l-value while all other literals are r-value?

Passing string literals as rvalue references

Why can I pass a string literal as a rvalue reference?

You cannot.

void take(const char(&&)[1]);

int main() {
    take(""); // error: candidate function not viable: expects an rvalue for 1st argument
}

You are probably confusing a property of the std::string standard library container:

void take(std::string&&);

int main() {
    // OK, creates a new temporary std::string, and through temporary
    // materialization, the rvalue reference std::string&& binds to it.
    take("");
}

More confusion about std::string

std::string a = "string1" + "string2"; if "string1" and "string2" are lvalues, how can their sum can be an rvalue?

You are confusing string literals, which are of type const char[N] with std::string, which is a container from the standard library. Also your code is ill-formed:

// error: invalid operands to binary expression ('const char[8]' and 'const char[8]')
std::string a = "string1" + "string2"

You can perform + between two objects of type std::string because std::string has an overloaded + operator:

auto a = std::string("string1") + std::string("string2");

Answer 4

The "rvalue" category (which includes "xvalue") is normally used for the expressions referring to objects that will soon be destroyed, and can have the resources they own reused.

The string literals exist until the program terminates, so they don't match the "will soon be destroyed" criteria.

Hence making them xvalues would be confusing (but I don't think it would break anything important; just &"abc" wouldn't compile anymore).

---

Why can I pass a string literal as a rvalue reference?

No you can't:

void a(const char (&)[4]) {}
void b(const char (&&)[4]) {}

int main()
{
    a("abc"); // ok
    b("abc"); // error: cannot bind rvalue reference of type 'const char (&&)[4]' to lvalue of type 'const char [4]'
}

When you're doing this: void a(std::string &&) {} a("abc"); the rvalue reference doesn't point to the literal. It points to a temporary std::string constructed from the literal.