Can I Reference Previous Members of an Initializer List?

by

So what we have here is aggregate initialization covered in section 8.5.1 of the draft C++ standard and it says:

An aggregate is an array or a class […]

and:

When an aggregate is initialized by an initializer list, as specified
in 8.5.4, the elements of the initializer list are taken as
initializers for the members of the aggregate, in increasing subscript
or member order. Each member is copy-initialized from the
corresponding initializer-clause […]

Although it seems reasonable that side effects from initializing each member of the aggregate should be sequenced before the next, since each element in the initializer list is a full expression. The standard does not actually guarantee this we can see this from defect report 1343 which says:

The current wording does not indicate that initialization of a non-class object is a full-expression, but presumably should do so.

and also notes:

Aggregate initialization could also involve more than one full-expression, so the limitation above to “initialization of a non-class object” is not correct.

and we can see from a related std-discussion topic Richard Smith says:

[intro.execution]p10: “A full-expression is an expression that is not
a subexpression of another expression. […] If a language construct
is defined to produce an implicit call of a function, a use of the
language construct is considered to be an expression for the purposes
of this definition.”

Since a braced-init-list is not an expression, and in this case it
does not result in a function call, 5 and s.i are separate
full-expressions. Then:

[intro.execution]p14: “Every value computation and side effect
associated with a full-expression is sequenced before every value
computation and side effect associated with the next full-expression
to be evaluated.”

So the only question is, is the side-effect of initializing s.i
“associated with” the evaluation of the full-expression “5”? I think
the only reasonable assumption is that it is: if 5 were initializing a
member of class type, the constructor call would obviously be part of
the full-expression by the definition in [intro.execution]p10, so it
is natural to assume that the same is true for scalar types.

However, I don’t think the standard actually explicitly says this
anywhere.

So this is currently not specified by the standard and can not be relied upon, although I would be surprised if an implementation did not treat it the way you expect.

For a simple case like this something similar to this seems a better alternative:

constexpr int value = 13 ;
const int foo[2] = {value, value+42};

Changes In C++17

The proposal P0507R0: Core Issue 1343: Sequencing of non-class initialization clarifies the full-expression point brought up here but does not answer the question about whether the side-effect of initialization is included in the evaluation of the full-expression. So it does not change that this is unspecified.

The relevant changes for this question are in [intro.execution]:

A constituent expression is defined as follows:

(9.1) — The constituent expression of an expression is that expression.

(9.2) — The constituent expressions of a braced-init-list or of a (possibly parenthesized) expression-list are the
constituent expressions of the elements of the respective list.

(9.3) — The constituent expressions of a brace-or-equal-initializer of the form = initializer-clause are the
constituent expressions of the initializer-clause.
[ Example:

struct A { int x; };
struct B { int y; struct A a; };
B b = { 5, { 1+1 } };

The constituent expressions of the initializer used for the initialization of b are 5 and 1+1. —end example ]

and [intro.execution]p12:

A full-expression is

(12.1) — an unevaluated operand (Clause 8),

(12.2) — a constant-expression (8.20),

(12.3) — an init-declarator (Clause 11) or a mem-initializer (15.6.2), including the constituent expressions of the
initializer,

(12.4) — an invocation of a destructor generated at the end of the lifetime of an object other than a temporary
object (15.2), or

(12.5) — an expression that is not a subexpression of another expression and that is not otherwise part of a
full-expression.

So in this case both 13 and foo[0] + 42 are constituent expression which are part of a full-expression. This is a break from the analysis here which posited that they would each be their own full-expressions.

Changes In C++20

The Designated Initialization proposal: P0329 contains the following addition which seems to make this well defined:

Add a new paragraph to 11.6.1 [dcl.init.aggr]:

The initializations of the elements of the aggregate are evaluated in the element order. That is,
all value computations and side effects associated with a given element are sequenced before those of any element that follows it in order.

We can see this is reflected in the latest draft standard.

More Related Contents:

  1. When is a private constructor not a private constructor?
  2. Initializing a member array in constructor initializer
  3. How do I initialize a member array with an initializer_list?
  4. Deleted default constructor. Objects can still be created… sometimes
  5. Are multiple mutations of the same variable within initializer lists undefined behavior pre C++11
  6. How to construct std::array object with initializer list? [duplicate]
  7. Is it legal to declare a constexpr initializer_list object?
  8. treating memory returned by operator new(sizeof(T) * N) as an array
  9. Casting double array to a struct of doubles
  10. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  11. Pointer interconvertibility vs having the same address
  12. Are non dereferenced iterators past the “one past-the-end” iterator of an array undefined behavior?
  13. Why isn’t `std::initializer_list` defined as a literal type?
  14. Dereferencing one past the end pointer to array type
  15. Call an array from within an array of structs in c++
  16. Static array vs. dynamic array in C++
  17. Can someone explain this template code that gives me the size of an array? [duplicate]
  18. May I treat a 2D array as a contiguous 1D array?
  19. How to initialize std::vector from C-style array?
  20. Is adding to a “char *” pointer UB, when it doesn’t actually point to a char array?
  21. Is the memory allocated for struct members continguous? What if a struct member is an array?
  22. Why does ‘std::vector b{2};’ create a 1-element vector, and not a 2-element one?
  23. C++ correct way to return pointer to array from function
  24. Statically declared 2-D array C++ as data member of a class [duplicate]
  25. what is the best modern c++ approach to construct and manipulate a 2d array [closed]
  26. How to convert a char array to a string?
  27. delete[] an array of objects
  28. array decay to pointer and overload resolution
  29. Do C++ enums Start at 0?
  30. Array of size defined by not constant variable

Leave a Comment