What expressions create xvalues?

by

There is a helpful non-normative note in the introduction to §5 (C++11 §5[expr]/6):

[ Note: An expression is an xvalue if it is:

  • the result of calling a function, whether implicitly or explicitly, whose return type is an rvalue reference to object type,

  • a cast to an rvalue reference to object type,

  • a class member access expression designating a non-static data member of non-reference type in which the object expression is an xvalue, or

  • a .* pointer-to-member expression in which the first operand is an xvalue and the second operand is a pointer to data member.

In general, the effect of this rule is that named rvalue references are treated as lvalues and unnamed rvalue references to objects are treated as xvalues; rvalue references to functions are treated as lvalues whether named or not. —end note ]

Searching through the rest of §5, this list appears exhaustive. The list is followed by an example:

struct A {
    int m;
};

A&& operator+(A, A);
A&& f();
A a;
A&& ar = static_cast<A&&>(a);

The expressions f(), f().m, static_cast<A&&>(a), and a + a are xvalues. The expression ar is an lvalue.

There are two common ways to get an xvalue expression:

  • Use std::move to move an object. std::move performs a static_cast to an rvalue reference type and returns the rvalue reference.

  • Use std::forward to forward an rvalue. std::forward is typically used in a function template to enable perfect forwarding of a function argument.

    If the argument provided to the function template was an rvalue, the parameter type will be an rvalue reference, which is an lvalue. In this case, std::forward performs a static_cast to an rvalue reference type and returns the rvalue reference.

    (Note: If the argument provided to the function template was an lvalue, the parameter type will be an lvalue reference and std::forward will return an lvalue reference.)

More Related Contents:

  1. Optimizing away a “while(1);” in C++0x
  2. Will std::string always be null-terminated in C++11?
  3. What exactly is the “immediate context” mentioned in the C++11 Standard for which SFINAE applies?
  4. Is a moved-from vector always empty?
  5. c++ access static members using null pointer
  6. Why is modifying a string through a retrieved pointer to its data not allowed?
  7. Get pointer to object from pointer to some member
  8. So why is i = ++i + 1 well-defined in C++11?
  9. Is it legal to declare a constexpr initializer_list object?
  10. Are notes and examples in the core language specification of the C++ Standard non-normative?
  11. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  12. Does this code from “The C++ Programming Language” 4th edition section 36.3.6 have well-defined behavior?
  13. Can C++ code be valid in both C++03 and C++11 but do different things?
  14. What is the value category of the operands of C++ operators when unspecified?
  15. Are int8_t and uint8_t intended to be char types?
  16. When do extra parentheses have an effect, other than on operator precedence?
  17. What is the difference between C++03 `throw()` specifier and C++11 `noexcept`?
  18. Is left-shifting (
  19. What is the purpose of a declaration like int (x); or int (x) = 10;
  20. Is writing to &str[0] buffer (of a std:string) well-defined behaviour in C++11?
  21. Does C++11 allow dollar signs in identifiers?
  22. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  23. Calling an explicit constructor with a braced-init list: ambiguous or not?
  24. Can we apply content not explicitly cited from the normative references to the C++ standard?
  25. Calling delete on NULL pointers – C++03 vs C++11
  26. std::tuple memory alignment
  27. Rvalues, lvalues and formal definitions
  28. What is use of the ref-qualifier `const &&`?
  29. memcpy/memmove to a union member, does this set the ‘active’ member?
  30. Overload resolution with ref-qualifiers

Leave a Comment