What are lvalues, rvalues, xvalues, and prvalues?

In C++, values can be classified into several categories based on their usage and characteristics. Understanding these categories is essential for effective memory management and optimization in C++. The four main categories are:

  • lvalue (locator value): An lvalue refers to an object that occupies a specific location in memory. You can take the address of an lvalue using the '&' operator. Examples of lvalues include variables and dereferenced pointers.
  • rvalue (read value): An rvalue is a temporary object that does not have a persistent memory location. It is typically used on the right side of an assignment expression. For example, literals like 5 or expressions like a + b are rvalues.
  • xvalue (expiring value): An xvalue represents an object that is about to be moved from, indicating that it may soon be destroyed. It appears in a context where the object can be moved efficiently, such as when utilizing move semantics in C++11.
  • prvalue (pure rvalue): A prvalue is a type of rvalue that is not tied to a memory address. It is used in expressions that do not have a name or an identifiable location in memory, like the result of a mathematical operation or an unnamed temporary object.

Here's an example illustrating these concepts in C++:

#include <iostream> using namespace std; void example() { int a = 5; // lvalue int &b = a; // lvalue reference to a int c = a + 2; // rvalue, result of a + 2 is a temporary value (prvalue) int &&d = std::move(c); // xvalue, representing a temporary value about to be moved cout << "a: " << a <<, b: " << b <<, c: " << c <<, d: " << d << endl; } int main() { example(); return 0; }

C++ lvalue rvalue xvalue prvalue move semantics memory management optimization

Related Questions

How do I avoid rehashing overhead with std::set in multithreaded code?

How do I find elements with custom comparators with std::set for embedded targets?

How do I erase elements while iterating with std::set for embedded targets?

How do I provide stable iteration order with std::unordered_map for large datasets?

How do I reserve capacity ahead of time with std::unordered_map for large datasets?

How do I erase elements while iterating with std::unordered_map in multithreaded code?

How do I provide stable iteration order with std::map for embedded targets?

How do I provide stable iteration order with std::map in multithreaded code?

How do I avoid rehashing overhead with std::map in performance-sensitive code?

How do I merge two containers efficiently with std::map for embedded targets?