Why is `i = ++i + 1` unspecified behavior?

by

You make the mistake of thinking of operator= as a two-argument function, where the side effects of the arguments must be completely evaluated before the function begins. If that were the case, then the expression i = ++i + 1 would have multiple sequence points, and ++i would be fully evaluated before the assignment began. That’s not the case, though. What’s being evaluated in the intrinsic assignment operator, not a user-defined operator. There’s only one sequence point in that expression.

The result of ++i is evaluated before the assignment (and before the addition operator), but the side effect is not necessarily applied right away. The result of ++i + 1 is always the same as i + 2, so that’s the value that gets assigned to i as part of the assignment operator. The result of ++i is always i + 1, so that’s what gets assigned to i as part of the increment operator. There is no sequence point to control which value should get assigned first.

Since the code is violating the rule that “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,” the behavior is undefined. Practically, though, it’s likely that either i + 1 or i + 2 will be assigned first, then the other value will be assigned, and finally the program will continue running as usual — no nasal demons or exploding toilets, and no i + 3, either.

More Related Contents:

  1. Using paragraphs 8.5.3p4 and p5 in the C++11 Standard, how do I prove that the snippet below doesn’t compile?
  2. Why aren’t variable-length arrays part of the C++ standard?
  3. Where do I find the current C or C++ standard documents?
  4. What can I do with a moved-from object?
  5. Array placement-new requires unspecified overhead in the buffer?
  6. Is “argv[0] = name-of-executable” an accepted standard or just a common convention?
  7. What are the new features in C++17?
  8. What’s the difference between __PRETTY_FUNCTION__, __FUNCTION__, __func__?
  9. Where exactly does C++ standard say dereferencing an uninitialized pointer is undefined behavior?
  10. Copy constructor and = operator overload in C++: is a common function possible?
  11. A most vexing parse error: constructor with no arguments
  12. C++ Static member method call on class instance
  13. Why do const references extend the lifetime of rvalues?
  14. Why does C++ output negative numbers when using modulo?
  15. C/C++ int[] vs int* (pointers vs. array notation). What is the difference?
  16. Computing length of a C string at compile time. Is this really a constexpr?
  17. Is right shift undefined behavior if the count is larger than the width of the type?
  18. What are declarations and declarators and how are their types interpreted by the standard?
  19. Defining a variable in the condition part of an if-statement?
  20. Base pointer to array of derived objects
  21. Standard Library Containers with additional optional template parameters?
  22. Is auto_ptr deprecated?
  23. What could C/C++ “lose” if they defined a standard ABI?
  24. Can I legally reinterpret_cast between layout-compatible standard-layout types?
  25. Is it legal/well-defined C++ to call a non-static method that doesn’t access members through a null pointer?
  26. ISO C++ standard draft
  27. Does the C++ standard specify anything on the representation of floating point numbers?
  28. Why must a std::ranges::filter_view object be non-const for querying its elements?
  29. Do pointers to string literals remain valid after a function returns?
  30. is size_t always unsigned?

Leave a Comment