Rvalues, lvalues and formal definitions

by

Some preliminary paragraphs first:

[basic]

3 An entity is a value, object, reference, function, enumerator,
type, class member, template, template specialization, namespace,
parameter pack, or this.

[dcl.type.simple]

4 The type denoted by decltype(e) is defined as follows:

  • if e is an unparenthesized id-expression or an unparenthesized class member access ([expr.ref]), decltype(e) is the type of the
    entity named by e. If there is no such entity, or if e names a set
    of overloaded functions, the program is ill-formed;

  • otherwise, if e is an xvalue, decltype(e) is T&&, where T is the type of e;

  • otherwise, if e is an lvalue, decltype(e) is T&, where T is the type of e;

  • otherwise, decltype(e) is the type of e.

[dcl.ref]

1 In a declaration T D where D has either of the forms

& attribute-specifier-seqopt D1 
&& attribute-specifier-seqopt D1

and the type of the identifier in the declaration T D1 is
“derived-declarator-type-list T,” then the type of the identifier
of D is “derived-declarator-type-list reference to T.”

[expr]

5 If an expression initially has the type “reference to T”
([dcl.ref], [dcl.init.ref]), the type is adjusted to T prior to any
further analysis. The expression designates the object or function
denoted by the reference, and the expression is an lvalue or an
xvalue, depending on the expression.

[expr.prim.general]

8 An identifier is an id-expression provided it has been suitably
declared (Clause [dcl.dcl]). The type of the expression is the type of
the identifier. The result is the entity denoted by the identifier.
The result is an lvalue if the entity is a function, variable, or data
member and a prvalue otherwise.

[expr.call]

10 A function call is an lvalue if the result type is an lvalue
reference type or an rvalue reference to function type, an xvalue if
the result type is an rvalue reference to object type, and a prvalue
otherwise.

Which now allows us to answer your questions.

In the line 1, x is an identifier (id-expression) that names a function parameter. Its type is int&&, and this is the type that decltype(x) returns. x is not an expression and has no value category.

Yes of sorts. x in the declaration is not an expression. But as an argument to decltype is an expression. However, it hits the special case of decltype‘s first bullet so the type of the identifier named by x is deduced, instead of the type of x as an expression.

In the line 2, x is an expression. Before type adjustment its type is int&&, and after the type becomes int. The value category is lvalue.

Yes.

In the line 3, std::move(x) is an expression. Its type before adjustment is int&&, after – int. The value category is xvalue.

Yes.

When we say that x has rvalue reference type, we refer either to the type of x as an identifier, or to the type of x as an expression before type adjustment.

Yes.

The word “type” in the statement “Each expression has some non-reference type, and each expression belongs to exactly one of the three primary value categories” at cppreference.com refers to the type after type adjustment.

Yes.

When Scott Meyers writes “If the type of an expression is an lvalue reference (e.g., T& or const T&, etc.), that expression is an lvalue.” he refers to the type before adjustment, and the second word “lvalue” refers to the value category.

Can’t really say for sure what Scott Meyers meant when he wrote this, but that is the only interpretation of the words that matches up with the standard, yes.

More Related Contents:

  1. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  2. Is null reference possible?
  3. Is the size of std::array defined by standard
  4. Capturing a reference by reference in a C++11 lambda
  5. Is a moved-from vector always empty?
  6. c++ access static members using null pointer
  7. how to initialize a constexpr reference
  8. Is it safe to push_back an element from the same vector?
  9. In C++11, does `i += ++i + 1` exhibit undefined behavior?
  10. Why is modifying a string through a retrieved pointer to its data not allowed?
  11. Get pointer to object from pointer to some member
  12. Is it legal to declare a constexpr initializer_list object?
  13. What is the difference between std::reference_wrapper and a simple pointer?
  14. What does the void() in decltype(void()) mean exactly?
  15. Can the point-of-instantiation be delayed until the end of the translation unit?
  16. Can C++ code be valid in both C++03 and C++11 but do different things?
  17. What is the value category of the operands of C++ operators when unspecified?
  18. How can an incomplete type be used as a template parameter to vector here?
  19. Is the Empty Base Class Optimization now a mandatory optimization (at least for standard-layout classes)?
  20. Is left-shifting (
  21. Is writing to &str[0] buffer (of a std:string) well-defined behaviour in C++11?
  22. Why can’t I initialize a reference in an initializer list with uniform initialization?
  23. Classes with both template and non-template conversion operators in the condition of switch statement
  24. Does C++11 allow dollar signs in identifiers?
  25. reinterpret_cast between char* and std::uint8_t* – safe?
  26. What is the difference between std::quick_exit and std::abort and why was std::quick_exit needed?
  27. Does C++11 change the behavior of explicitly calling std::swap to ensure ADL-located swap’s are found, like boost::swap?
  28. Why does std::forward have two overloads?
  29. C++11 cross compiler/standard library random distribution reproducibility
  30. Can using a lambda in header files violate the ODR?

Leave a Comment