Understanding the example on lvalue-to-rvalue conversion

by

This is because y.n is not odr-used and therefore does not require an access to y.n the rules for odr-use are covered in 3.2 and says:

A variable x whose name appears as a potentially-evaluated expression ex is odr-used unless applying the
lvalue-to-rvalue conversion (4.1) to x yields a constant expression (5.19) that does not invoke any non-trivial
functions and, if x is an object, ex is an element of the set of potential results of an expression e, where
either the lvalue-to-rvalue conversion (4.1) is applied to e, or e is a discarded-value expression

Note, Ben Voigt made some helpful comments that clarified this one a bit. So the working assumption here is that x would be:

y

and e would be(the different expression that e is defined for is covered in paragraph 2 of section 3.2):

(b ? y : x).n

y yields a constant expression and the lvalue-to-rvalue conversion is applied to the expression e.

Since f yields a lambda which captures f‘s local variables by reference x is no longer valid once the call to f is done since x is an automatic variable inside f. Since y is a constant expression it acts as if y.n was not accessed and therefore we don’t have the same lifetime issue.

Your example is included in N3939 section 4.1 [conv.lval] and right before that example it says:

When an lvalue-to-rvalue conversion is applied to an expression e, and either

and includes the following bullet which the examle belongs to:

the evaluation of e results in the evaluation of a member ex of the set of potential results of e, and
ex names a variable x that is not odr-used by ex (3.2),

then:

the value contained in the referenced object is not accessed

This was applied to the C++14 draft standard due to defect report 1773 .

More Related Contents:

  1. Self-initialization of a static constexpr variable, is it well-formed?
  2. Why isn’t `std::initializer_list` defined as a literal type?
  3. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  4. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  5. static_assert dependent on non-type template parameter (different behavior on gcc and clang)
  6. Is a pointer with the right address and type still always a valid pointer since C++17?
  7. Deleted default constructor. Objects can still be created… sometimes
  8. Can I obtain C++ type names in a constexpr way?
  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. Static member access in constant expressions
  12. Compile-time or runtime detection within a constexpr function
  13. Why doesn’t an if constexpr make this core constant expression error disappear?
  14. Will consteval functions allow template parameters dependent on function arguments?
  15. Is a constexpr array necessarily odr-used when subscripted?
  16. Why was the space character not chosen for C++14 digit separators?
  17. Throw in constexpr function
  18. Classes with both template and non-template conversion operators in the condition of switch statement
  19. Why does constexpr static member (of type class) require a definition?
  20. Why is `make_unique` disallowed?
  21. Injected class name compiler discrepancy
  22. What changes to C++ made copy initialization work for class with explicit constructor?
  23. Directly write into char* buffer of std::string
  24. Does the standard mandate an lvalue-to-rvalue conversion of the pointer variable when applying indirection?
  25. Capturing a reference by reference in a C++11 lambda
  26. “inline” keyword vs “inlining” concept
  27. Casting double array to a struct of doubles
  28. Are pointer variables just integers with some operators or are they “symbolic”?
  29. Observable behavior and undefined behavior — What happens if I don’t call a destructor?
  30. Dereferencing one past the end pointer to array type

Leave a Comment