What made i = i++ + 1; legal in C++17?

by

In C++11 the act of “assignment”, i.e. the side-effect of modifying the LHS, is sequenced after the value computation of the right operand. Note that this is a relatively “weak” guarantee: it produces sequencing only with relation to value computation of the RHS. It says nothing about the side-effects that might be present in the RHS, since occurrence of side-effects is not part of value computation. The requirements of C++11 establish no relative sequencing between the act of assignment and any side-effects of the RHS. This is what creates the potential for UB.

The only hope in this case is any additional guarantees made by specific operators used in RHS. If the RHS used a prefix ++, sequencing properties specific to the prefix form of ++ would have saved the day in this example. But postfix ++ is a different story: it does not make such guarantees. In C++11 the side-effects of = and postfix ++ end up unsequenced with relation to each other in this example. And that is UB.

In C++17 an extra sentence is added to the specification of assignment operator:

The right operand is sequenced before the left operand.

In combination with the above it makes for a very strong guarantee. It sequences everything that happens in the RHS (including any side-effects) before everything that happens in the LHS. Since the actual assignment is sequenced after LHS (and RHS), that extra sequencing completely isolates the act of assignment from any side-effects present in RHS. This stronger sequencing is what eliminates the above UB.

(Updated to take into account @John Bollinger’s comments.)

More Related Contents:

  1. reinterpret_cast creating a trivially default-constructible object
  2. Is stateful metaprogramming ill-formed (yet)?
  3. Is a pointer with the right address and type still always a valid pointer since C++17?
  4. How is P0522R0 breaking code?
  5. structured bindings: when something looks like a reference and behaves similarly to a reference, but it’s not a reference
  6. std::ignore with structured bindings?
  7. Deducing first template argument with other template parameters defaulted
  8. Does the behavior of guaranteed copy elision depend on existence of user-defined copy constructor?
  9. Self-initialization of a static constexpr variable, is it well-formed?
  10. Can std::launder be used to convert an object pointer to its enclosing array pointer?
  11. Static member access in constant expressions
  12. Pointer interconvertibility vs having the same address
  13. Why doesn’t an if constexpr make this core constant expression error disappear?
  14. Is it allowed for a compiler to optimize away a local volatile variable?
  15. Will I be able to declare a constexpr lambda inside a template parameter?
  16. What changes to C++ made copy initialization work for class with explicit constructor?
  17. Can I use the result of a C++17 captureless lambda constexpr conversion operator as a function pointer template non-type argument?
  18. Directly write into char* buffer of std::string
  19. Will std::string always be null-terminated in C++11?
  20. Sequence points and partial order
  21. Is the behaviour of i = i++ really undefined?
  22. About binding a const reference to a sub-object of a temporary
  23. Explicit specialization in non-namespace scope does not compile in GCC
  24. Aliasing T* with char* is allowed. Is it also allowed the other way around?
  25. Is there a (semantic) difference between the return value of placement new and the casted value of its operand?
  26. Are multiple mutations of the same variable within initializer lists undefined behavior pre C++11
  27. Class template argument deduction not working with alias template
  28. Does this really break strict-aliasing rules?
  29. Why is std::iterator deprecated?
  30. Does C++11 change the behavior of explicitly calling std::swap to ensure ADL-located swap’s are found, like boost::swap?

Leave a Comment