In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?

by

tl;dr: The sequence of the modifications and reads performed in (i+=10)+=10 is well defined in both C++98 and C++11, however in C++98 this is not sufficient to make the behavior defined.

In C++98 multiple modifications to the same object without an intervening sequence-point results in undefined behavior, even when the order of those modifications is well specified. This expression does not contain any sequence points and so the fact that it consists of two modifications is sufficient to render its behavior undefined.

C++11 doesn’t have sequence points and only requires that the modifications of an object be ordered with respect to each other and to reads of the same object to produce defined behavior.

Therefore the behavior is undefined in C++98 but well defined in C++11.

C++98

C++98 clause [expr] 5 p4

Except where noted, the order of evaluation of operands of individual operators and subexpressions of individual expression, and the order in which side effects take place, is unspecified.

C++98 clause [expr.ass] 5.17 p1

The result of the assignment operation is the value stored in the left operand after the assignment has taken place; the result is an lvalue

So I believe the order is specified, however I don’t see that that alone is enough to create a sequence point in the middle of an expression. And continuing on with the quote of [expr] 5 p4:

Between the previous and next sequence point a scalar object shall have its stored value modified at most once by the evaluation of an expression.

So even though the order is specified it appears to me that this is not sufficient for defined behavior in C++98.

C++11

C++11 does away sequence points for the much clearer idea of sequence-before and sequenced-after. The language from C++98 is replaced with

C++11 [intro.execution] 1.9 p15

Except where noted, evaluations of operands of individual operators and of subexpressions of individual expressions are unsequenced. […]

If a side effect on a scalar object is unsequenced relative to either another side effect on the same scalar object or a value computation using the value of the same scalar object, the behavior is undefined.

C++11 [expr.ass] 5.17 p1

In all cases, the assignment is sequenced after the value computation of the right and left operands, and before the value computation of the assignment expression.

So while being ordered was not sufficient to make the behavior defined in C++98, C++11 has changed the requirement such that being ordered (i.e., sequenced) is sufficient.

(And it seems to me that the extra flexibility afforded by ‘sequence before’ and ‘sequenced after’ has lead to a much more clear, consistent, and well specified language.)

It seems unlikely to me that any C++98 implementation would actually do anything surprising when the sequence of operations is well specified even if that is insufficient to produce technically well defined behavior. As an example, the internal representation of this expression produced by Clang in C++98 mode has well defined behavior and does the expected thing.

More Related Contents:

  1. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  2. Optimizing away a “while(1);” in C++0x
  3. In C++11, does `i += ++i + 1` exhibit undefined behavior?
  4. So why is i = ++i + 1 well-defined in C++11?
  5. Can C++ code be valid in both C++03 and C++11 but do different things?
  6. Calling delete on NULL pointers – C++03 vs C++11
  7. A positive lambda: ‘+[]{}’ – What sorcery is this? [duplicate]
  8. Do I need to cast to unsigned char before calling toupper(), tolower(), et al.?
  9. reinterpret_cast creating a trivially default-constructible object
  10. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  11. Why would the behavior of std::memcpy be undefined for objects that are not TriviallyCopyable?
  12. When is a private constructor not a private constructor?
  13. Is this infinite recursion UB?
  14. Matching alias template as template argument
  15. Do I really need to implement user-provided constructor for const objects?
  16. Default, value and zero initialization mess
  17. Lambda capture and parameter with same name – who shadows the other? (clang vs gcc)
  18. Is std::abs(0u) ill-formed?
  19. Why does the standard differentiate between direct-list-initialization and copy-list-initialization?
  20. What does the void() in decltype(void()) mean exactly?
  21. Can the point-of-instantiation be delayed until the end of the translation unit?
  22. Implementing a std::vector like container without undefined behavior
  23. Is a constexpr array necessarily odr-used when subscripted?
  24. Is the Empty Base Class Optimization now a mandatory optimization (at least for standard-layout classes)?
  25. Legal to overwrite std::string’s null terminator?
  26. Dangling references and undefined behavior
  27. reinterpret_cast between char* and std::uint8_t* – safe?
  28. What is the difference between std::quick_exit and std::abort and why was std::quick_exit needed?
  29. Does C++11 change the behavior of explicitly calling std::swap to ensure ADL-located swap’s are found, like boost::swap?
  30. C++11 cross compiler/standard library random distribution reproducibility

Leave a Comment