Are multiple mutations of the same variable within initializer lists undefined behavior pre C++11

by

The code is not undefined pre-C++11 but the evaluation order is unspecified. If we look at the draft standard section 1.9 Program execution paragraph 12 says:

A full-expression is an expression that is not a subexpression of another expression. […]

and paragraph 15 says:

There is a sequence point at the completion of evaluation of each full-expression12).

then the question is whether count++, count++ is a full expression and each count++ a sub-expression or is each count++ it’s own full expression and therefore there is sequence point after each one? if we look at the grammar for this initialization from section 8.5 Initializers:

initializer-clause:
  assignment-expression
  { initializer-list ,opt }
  { }
initializer-list:
  initializer-clause
  initializer-list , initializer-clause

the only expression we have is an assignment-expression and the , separating the components is part of the initializer-list and and not part of an expression and therefore each count++ is a full expression and there is a sequence point after each one.

This interpretation is confirmed by the following gcc bug report, which has very similar code to mine(I came up with my example way before I found this bug report):

int count = 23;
int foo[] = { count++, count++, count++ };

which ends up as defect report 430, which I will quote:

[…]I believe the standard is clear that each initializer expression in the above is a full-expression (1.9 [intro.execution]/12-13; see also issue 392) and therefore there is a sequence point after each expression (1.9 [intro.execution]/16). I agree that the standard does not seem to dictate the order in which the expressions are evaluated, and perhaps it should. Does anyone know of a compiler that would not evaluate the expressions left to right?

More Related Contents:

  1. Accessing inactive union member and undefined behavior?
  2. When does invoking a member function on a null instance result in undefined behavior?
  3. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  4. Optimizing away a “while(1);” in C++0x
  5. Does initialization entail lvalue-to-rvalue conversion? Is `int x = x;` UB?
  6. Do I need to cast to unsigned char before calling toupper(), tolower(), et al.?
  7. Is `reinterpret_cast`ing between hardware SIMD vector pointer and the corresponding type an undefined behavior?
  8. Why does left shift operation invoke Undefined Behaviour when the left side operand has negative value?
  9. Does “Undefined Behavior” really permit *anything* to happen? [duplicate]
  10. Where exactly does C++ standard say dereferencing an uninitialized pointer is undefined behavior?
  11. Difference between Undefined Behavior and Ill-formed, no diagnostic message required
  12. Is passing a C++ object into its own constructor legal?
  13. Are multiple mutations within initializer lists undefined behavior?
  14. Does not evaluating the expression to which sizeof is applied make it legal to dereference a null or invalid pointer inside sizeof in C++?
  15. In C++11, does `i += ++i + 1` exhibit undefined behavior?
  16. So why is i = ++i + 1 well-defined in C++11?
  17. Is it legal to declare a constexpr initializer_list object?
  18. Why is f(i = -1, i = -1) undefined behavior?
  19. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  20. Implementing a std::vector like container without undefined behavior
  21. Can I Reference Previous Members of an Initializer List?
  22. Are pointer variables just integers with some operators or are they “symbolic”?
  23. The behaviour of floating point division by zero
  24. Can branches with undefined behavior be assumed unreachable and optimized as dead code?
  25. Why isn’t `std::initializer_list` defined as a literal type?
  26. Dangling references and undefined behavior
  27. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  28. Observable behavior and undefined behavior — What happens if I don’t call a destructor?
  29. Why class data members can’t be initialized by direct initialization syntax?
  30. Is char default-promoted?

Leave a Comment