Are multiple mutations within initializer lists undefined behavior?

by

Yes, the code is valid and does not have undefined behavior. Expressions in an initizalizer list are evaluated left-to-right and sequenced before the evaluation of the constructor of S. Therefore, your program should consistently assign value 2 to variable i.

Quoting § 8.5.4 of the C++ Standard:

“Within the initializer-list of a braced-init-list, the initializer-clauses, including any that result from pack expansions (14.5.3), are evaluated in the order in which they appear. That is, every value computation and side effect associated with a given initializer-clause is sequenced before every value computation and side effect associated with any initializer-clause that follows it in the comma-separated list of the initializer-list.”

Thus, what happens is:

  1. ++i gets evaluated, yielding i = 1 (first argument of S‘s constructor);
  2. ++i gets evaluated, yielding i = 2 (second argument of S‘s constructor);
  3. S‘s constructor is executed;
  4. S‘s conversion operator is executed, returning value 2;
  5. value 2 is assigned to i (which already had value 2).

Another relevant paragraph of the Standard is § 1.9/15, which also mentions similar examples that do have undefined behavior:

i = v[i++]; // the behavior is undefined
i = i++ + 1; // the behavior is undefined

However, the same paragraph says:

“Except where noted, evaluations of operands of individual operators and of subexpressions of individual expressions are unsequenced. […] When calling a function (whether or not the function is inline), every value computation and side effect associated with any argument expression, or with the postfix expression designating the called function, is sequenced before execution of every expression or statement in the body of the called function.“

Since 1) the evaluation of the expressions in the initializer list is sequenced left-to-right, 2) the execution of the constructor of S is sequenced after the evaluation of all expressions in the initializer list, and 3) the assignment to i is sequenced after the execution of the constructor of S (and its conversion operator), the behavior is well-defined.

More Related Contents:

  1. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  2. Is signed integer overflow still undefined behavior in C++?
  3. initializer_list and move semantics
  4. Optimizing away a “while(1);” in C++0x
  5. Why do constant expressions have an exclusion for undefined behavior?
  6. initializer_list and template type deduction
  7. Initializing a member array in constructor initializer
  8. lifetime of a std::initializer_list return value
  9. When to use the brace-enclosed initializer?
  10. Why does auto x{3} deduce an initializer_list?
  11. Is this infinite recursion UB?
  12. How do I initialize a member array with an initializer_list?
  13. Brace-enclosed initializer list constructor
  14. Order of evaluation of elements in list-initialization
  15. Why doesn’t my template accept an initializer list
  16. Are multiple mutations of the same variable within initializer lists undefined behavior pre C++11
  17. How to construct std::array object with initializer list? [duplicate]
  18. In C++11, does `i += ++i + 1` exhibit undefined behavior?
  19. Initializer-list-constructing a vector of noncopyable (but movable) objects
  20. So why is i = ++i + 1 well-defined in C++11?
  21. Is it legal to declare a constexpr initializer_list object?
  22. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  23. Why is locking a std::mutex twice ‘Undefined Behaviour’?
  24. Double delete in initializer_list vs 2013
  25. Why can’t I initialize a reference in an initializer list with uniform initialization?
  26. Range-based for with brace-initializer over non-const values?
  27. reinterpret_cast from object to first member
  28. What would a std::map extended initializer list look like?
  29. Initialization difference with or without curly braces in C++
  30. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?

Leave a Comment