About binding a const reference to a sub-object of a temporary

by

This is covered by CWG 1651:

The resolution of issues 616 and 1213, making the result of a member
access or subscript expression applied to a prvalue an xvalue, means
that binding a reference to such a subobject of a temporary does not
extend the temporary’s lifetime. 12.2 [class.temporary] should be
revised to ensure that it does.

The status quo is that only prvalues are treated as referring to temporaries – thus [class.temporary]/5 (“The second context is when a reference is bound to a temporary.”) is not considered applicable. Clang and GCC have not actually implemented issue 616’s resolution, though. center().x is treated as a prvalue by both. My best guess:

  • GCC simply didn’t react to any DRs yet, at all. It doesn’t extend lifetime when using scalar subobjects, because those are not covered by [dcl.init.ref]/(5.2.1.1)†. So the complete temporary object doesn’t need to live on (see aschelper’s answer), and it doesn’t, because the reference doesn’t bind directly. If the subobject is of class or array type, the reference binds directly, and GCC extends the temporary’s lifetime. This has been noted in DR 60297.

  • Clang recognizes member access and implemented the “new” lifetime extension rules already – it even handles casts. Technically speaking, this is not consistent with the way it handles value categories. However, it is more sensible and will be the correct behavior once the aforementioned DR is resolved.

I’d therefore say that GCC is correct by current wording, but current wording is defective and vague, and Clang already implemented the pending resolution to DR 1651, which is N3918. This paper covers the example very clearly:

If E1 is a temporary expression and E2 does not designate a
bit-field, then E1.E2 is a temporary expression.

center() is a temporary expression as per the paper’s wording for [expr.call]/11. Thus its modified wording in the aforementioned [class.temporary] /5 applies:

The second context is when a reference does not bind directly (8.5.3
dcl.init.ref) or is initialized with a temporary expression (clause 5). The corresponding temporary
object (if any) persists for the lifetime of the reference except: […inapplicable exceptions…]

Voilà, we have lifetime extension. Note that “the corresponding temporary object” is not clear enough, one of the reasons for the proposal’s deferment; it will assuredly be adopted once it gets revised.

†

is an xvalue (but not a bit-field), class prvalue, array prvalue or function lvalue and “cv1 T1” is reference-compatible with “cv2 T2”, or […]

Indeed, GCC respects this fully and will extend lifetime if the subobject has array type.

More Related Contents:

  1. What happens if you static_cast invalid value to enum class?
  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 passing a C++ object into its own constructor legal?
  5. Explicit specialization in non-namespace scope does not compile in GCC
  6. Matching alias template as template argument
  7. Aliasing T* with char* is allowed. Is it also allowed the other way around?
  8. Unsequenced value computations (a.k.a sequence points)
  9. Is it legal to compare dangling pointers?
  10. Is there a (semantic) difference between the return value of placement new and the casted value of its operand?
  11. Are multiple mutations of the same variable within initializer lists undefined behavior pre C++11
  12. Why is “using namespace X;” not allowed at class/struct level?
  13. Why does same_as concept check type equality twice?
  14. Placement new and assignment of class with const member
  15. Does a declaration using “auto” match an extern declaration that uses a concrete type specifier?
  16. Lambda capture and parameter with same name – who shadows the other? (clang vs gcc)
  17. Repeated typedefs – invalid in C but valid in C++?
  18. Does this really break strict-aliasing rules?
  19. So why is i = ++i + 1 well-defined in C++11?
  20. When do extra parentheses have an effect, other than on operator precedence?
  21. What is the difference between C++03 `throw()` specifier and C++11 `noexcept`?
  22. Is reinterpret_cast type punning actually undefined behavior?
  23. Familiar template syntax for generic lambdas
  24. Legal to overwrite std::string’s null terminator?
  25. Is it allowed for a compiler to optimize away a local volatile variable?
  26. Is there some meaningful statistical data to justify keeping signed integer arithmetic overflow undefined?
  27. Is it a strict aliasing violation to alias a struct as its first member?
  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