Is a constexpr array necessarily odr-used when subscripted?

by

First use of A::a:

int a = A::a[0];

The initializer is a constant expression, but that doesn’t stop A::a from being odr-used here. And, indeed, A::a is odr-used by this expression.

Starting from the expression A::a[0], let’s walk through [basic.def.odr](3.2)/3 (for future readers, I’m using the wording from N3936):

A variable x [in our case, A::a] whose name appears as a potentially-evaluated expression ex [in our case, the id-expression A::a] is odr-used unless

  • applying the lvalue-to-rvalue conversion to x yields a constant expression [it does]
    that does not invoke any non-trivial functions [it does not] and,

  • if x is an object [it is],

    • ex is an element of the set of potential results of an expression e, where either the lvalue-to-rvalue conversion is applied to e, or e is a discarded-value expression.

So: what possible values of e are there? The set of potential results of an expression is a set of subexpressions of the expression (you can check this by reading through [basic.def.odr](3.2)/2), so we only need to consider expressions of which ex is a subexpression. Those are:

A::a
A::a[0]

Of these, the lvalue-to-rvalue conversion is not applied immediately to A::a, so we only consider A::a[0]. Per [basic.def.odr](3.2)/2, the set of potential results of A::a[0] is empty, so A::a is odr-used by this expression.

Now, you could argue that we first rewrite A::a[0] to *(A::a + 0). But that changes nothing: the possible values of e are then

A::a
A::a + 0
(A::a + 0)
*(A::a + 0)

Of these, only the fourth has an lvalue-to-rvalue conversion applied to it, and again, [basic.def.odr](3.2)/2 says that the set of potential results of *(A::a + 0) is empty. In particular, note that array-to-pointer decay is not an lvalue-to-rvalue conversion ([conv.lval](4.1)), even though it converts an array lvalue to a pointer rvalue — it’s an array-to-pointer conversion ([conv.array](4.2)).

Second use of A::a:

int b  [A::a[1]];

This is no different from the first case, according to the standard. Again, A::a[1] is a constant expression, thus this is a valid array bound, but a compiler is still permitted to emit code at runtime to compute this value, and the array bound still odr-uses A::a.

Note in particular that constant expressions are (by default) potentially-evaluated expressions. Per [basic.def.odr](3.2)/2:

An expression is potentially evaluated unless it is an unevaluated operand (Clause 5) or a subexpression thereof.

[expr](5)/8 just redirects us to other subclauses:

In some contexts, unevaluated operands appear (5.2.8, 5.3.3, 5.3.7, 7.1.6.2). An unevaluated operand is not evaluated.

These subclauses say that (respectively) the operand of some typeid expressions, the operand of sizeof, the operand of noexcept, and the operand of decltype are unevaluated operands. There are no other kinds of unevaluated operand.

More Related Contents:

  1. Is it legal to declare a constexpr initializer_list object?
  2. What’s the difference between constexpr and const?
  3. A positive lambda: ‘+[]{}’ – What sorcery is this? [duplicate]
  4. When does a constexpr function get evaluated at compile time?
  5. reinterpret_cast creating a trivially default-constructible object
  6. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  7. Why would the behavior of std::memcpy be undefined for objects that are not TriviallyCopyable?
  8. When is a private constructor not a private constructor?
  9. C++11 – static_assert within constexpr function?
  10. Why do we need to mark functions as constexpr?
  11. Is constexpr supported with lambda functions / expressions?
  12. Matching alias template as template argument
  13. static constexpr member of same type as class being defined
  14. Does static constexpr variable inside a function make sense?
  15. Do I really need to implement user-provided constructor for const objects?
  16. Lambda capture and parameter with same name – who shadows the other? (clang vs gcc)
  17. Is std::abs(0u) ill-formed?
  18. Why does the standard differentiate between direct-list-initialization and copy-list-initialization?
  19. Is it possible to declare constexpr class in a header and define it in a separate .cpp file?
  20. Lookup table with constexpr
  21. Is the Empty Base Class Optimization now a mandatory optimization (at least for standard-layout classes)?
  22. Why can I call a non-constexpr function inside a constexpr function?
  23. Why does constexpr static member (of type class) require a definition?
  24. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  25. Calling an explicit constructor with a braced-init list: ambiguous or not?
  26. Can we apply content not explicitly cited from the normative references to the C++ standard?
  27. Calling delete on NULL pointers – C++03 vs C++11
  28. std::tuple memory alignment
  29. Rvalues, lvalues and formal definitions
  30. What is use of the ref-qualifier `const &&`?

Leave a Comment