C++ Value Categories: lvalue, prvalue, xvalue, and Their Role in Function Returns and Move Semantics

This article explores the evolution of C++ value categories—lvalue, prvalue, and xvalue—by examining how the language and compiler handle function return values, parameter passing, and object lifetimes.

1. From C to C++: Stack Layout and Return Values

In C, function parameters and local variables are stored on the stack. The article shows a simple C function and its AMD64 assembly, illustrating that arguments and return values are passed via registers or stack slots.

void Demo() {

int a = 0;

long b = 1;

short c = 2;

}

Corresponding assembly (simplified):

push   rbp

mov    rbp, rsp

mov    DWORD PTR [rbp-4], 0

mov    QWORD PTR [rbp-16], 1

mov    WORD PTR [rbp-18], 2

pop    rbp

ret

When a function returns a scalar, the value is placed in a register (e.g., eax). int Demo() { return 5; } Assembly:

push   rbp

mov    rbp, rsp

mov    eax, 5

pop    rbp

ret

2. Returning Complex Types

For structs, the compiler may allocate a hidden “out‑parameter” on the caller’s stack and pass its address to the callee. The callee constructs the object in that memory.

struct Test { long a, b; };

Test Demo() {

Test t = {1, 2};

return t;

}

Assembly (simplified):

push   rbp

mov    rbp, rsp

mov    QWORD PTR [rbp-16], rdi   ; store hidden out‑param address

...                         ; construct local t

mov    rax, QWORD PTR [rbp-16]   ; return pointer

pop    rbp

ret

If the caller receives the result in a variable, the compiler may copy from the temporary (xvalue) into the variable, then destroy the temporary. Test t = Demo(); Resulting assembly shows an extra copy and a destructor call for the temporary.

3. Summary of Return‑Value Handling

When the result fits in a register, it is returned directly (prvalue).

When the result needs memory, the caller provides a hidden slot; the callee writes into it (treated as an lvalue).

If only a part of the result is used, the compiler creates an anonymous temporary (xvalue) that is destroyed after the expression.

4. References and Addressability

Const references can bind to any rvalue (including temporaries). The reference itself is an lvalue, but it extends the lifetime of the temporary it binds to.

const Test& ref = Demo();   // extends lifetime of the temporary

Non‑const lvalue references cannot bind to temporaries because temporaries have no addressable storage. Test& r = Demo(); // illegal Thus, a const reference to a return value behaves like a normal variable that owns its storage.

5. Rvalue References and Move Semantics

Rvalue references ( T&&) were introduced to enable move semantics. When a function overload takes T&&, a direct function return value prefers that overload.

void f(const Test&);   // for lvalues

void f(Test&&);        // for temporaries

f(Demo());            // calls the rvalue‑reference overload

Inside a move constructor, the source object’s resources are transferred (shallow copy) and the source is left in a valid but unspecified state (often nullified).

Test(Test&& other) : buf_(other.buf_) {

other.buf_ = nullptr;

}

Using a variable to receive a return value now benefits from copy‑elision (C++17), so no extra temporary is created. Test t = Demo(); // copy‑elision, no extra xvalue 6. std::move std::move is a utility that casts an lvalue to an rvalue reference, allowing the programmer to explicitly request move semantics.

String s1;

String s2 = std::move(s1);   // forces move construction

Note that std::move does not change the object’s actual value category; it merely enables overload resolution to select the move constructor.

7. Practical Takeaways

Value categories exist to reconcile C‑style low‑level calling conventions with high‑level language semantics.

prvalue = pure rvalue (no storage), xvalue = “expiring” value with temporary storage, lvalue = named object with storage.

Const references extend the lifetime of temporaries; rvalue references enable move semantics.

Copy‑elision (C++17) removes unnecessary temporaries for return‑value initialization. std::move is a cast, not a mover; the actual move occurs in the move constructor/assignment.