What standard clause mandates this lvalue-to-rvalue conversion?

by

I find it easier (if maybe not 100% precise) to think of lvalue-s as real objects and rvalue-s as the value stored in the object. The expression x is an lvalue expression that refers to the object x defined in the first line, but when used as the right hand side of an assignment to a type that is not a user defined type the actual value is read, and that is where the conversion from lvalue to rvalue is performed: reading the contents of the object.

As to the specific clause in the standard that dictates that conversion… well, the closest that I can think is 4.1 [conv.lvalue]/2 (Lvalue to Rvalue conversion):

The value contained in the object indicated by the lvalue is the rvalue result.

The requirement that the right hand side of the assignment is an rvalue is either implicit or missing from 5.17 [expr.ass], but that is the case or else the following expression would be an error since the rhs is an rvalue and there is no rvalue-to-lvalue conversion:

int x = 5;

EDIT: For initialization, 8.5 [dcl.init]/14, last bullet (which refers to fundamental types) states (emphasis mine):

  • Otherwise, the initial value of the object being initialized is the (possibly converted) value of the initializer expression. […]

That value there means that the lvalue expression in your example is read (i.e. converted to an rvalue). At any rate the previous paragraph that referred to assignment could be applied here: if initialization required an lvalue rather than an rvalue, the expression int i = 0; would be ill-formed.

More Related Contents:

  1. Order of evaluation of arguments using std::cout
  2. Take the address of a one-past-the-end array element via subscript: legal by the C++ Standard or not?
  3. Do I need to cast to unsigned char before calling toupper(), tolower(), et al.?
  4. Do distinct functions have distinct addresses?
  5. Why class data members can’t be initialized by direct initialization syntax?
  6. Is adding to a “char *” pointer UB, when it doesn’t actually point to a char array?
  7. Efficient unsigned-to-signed cast avoiding implementation-defined behavior
  8. Is a pointer with the right address and type still always a valid pointer since C++17?
  9. Floating point comparison revisited
  10. Pure virtual functions may not have an inline definition. Why?
  11. What does the void() in decltype(void()) mean exactly?
  12. Are non dereferenced iterators past the “one past-the-end” iterator of an array undefined behavior?
  13. Can the point-of-instantiation be delayed until the end of the translation unit?
  14. Is most vexing parse a formally defined concept
  15. Pseudo-destructor call does not destroy an object
  16. Why is a constexpr function on a reference not constexpr?
  17. Will consteval functions allow template parameters dependent on function arguments?
  18. Is the Empty Base Class Optimization now a mandatory optimization (at least for standard-layout classes)?
  19. Classes with both template and non-template conversion operators in the condition of switch statement
  20. Is incrementing a null pointer well-defined?
  21. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  22. Observable behavior and undefined behavior — What happens if I don’t call a destructor?
  23. Calling an explicit constructor with a braced-init list: ambiguous or not?
  24. What changes to C++ made copy initialization work for class with explicit constructor?
  25. std::tuple memory alignment
  26. Appending std::vector to itself, undefined behavior?
  27. Rvalues, lvalues and formal definitions
  28. What is the modern, correct way to do type punning in C++?
  29. Overload resolution with ref-qualifiers
  30. Does the standard mandate an lvalue-to-rvalue conversion of the pointer variable when applying indirection?

Leave a Comment