Sequence points and partial order

by

The C standard says this about assignment operators (C90 6.3.16 or C99 6.5.16 Assignment operators):

The side effect of updating the stored value of the left operand shall occur between the previous and the next sequence point.

It seems to me that in the statement:

i=(i,i++,i)+1;

the sequence point ‘previous’ to the assignment operator would be the second comma operator and the ‘next’ sequence point would be the end of the expression. So I’d say that the expression doesn’t invoke undefined behavior.

However, this expression:

*(some_ptr + i) = (i,i++,i)+1;

would have undefined behavior because the order of evaluation of the 2 operands of the assignment operator is undefined, and in this case instead of the problem being when the assignment operator’s side effect takes place, the problem is you don’t know whether the value of i used in the left handle operand will be evaluated before or after the right hand side. This order of evaluation problem doesn’t occur in the first example because in that expression the value of i isn’t actually used in the left-hand side – all that the assignment operator is interested in is the “lvalue-ness” of i.

But I also think that all this is sketchy enough (and my understanding of the nuances involved are sketchy enough) that I wouldn’t be surprised if someone can convince me otherwise (on either count).

More Related Contents:

  1. When does invoking a member function on a null instance result in undefined behavior?
  2. Optimizing away a “while(1);” in C++0x
  3. Is `reinterpret_cast`ing between hardware SIMD vector pointer and the corresponding type an undefined behavior?
  4. Does “Undefined Behavior” really permit *anything* to happen? [duplicate]
  5. What made i = i++ + 1; legal in C++17?
  6. What is this smiley-with-beard expression: “”?
  7. Is a moved-from vector always empty?
  8. std::ignore with structured bindings?
  9. Why is it not possible to overload class templates?
  10. treating memory returned by operator new(sizeof(T) * N) as an array
  11. Is circumventing a class’ constructor legal or does it result in undefined behaviour?
  12. Static member access in constant expressions
  13. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  14. Why does `int ;` compile fine in C, but not in C++?
  15. What happened to the “aggregate or union type that includes one of the aforementioned types” strict aliasing rule?
  16. Can I Reference Previous Members of an Initializer List?
  17. Does this code from “The C++ Programming Language” 4th edition section 36.3.6 have well-defined behavior?
  18. Are int8_t and uint8_t intended to be char types?
  19. Why doesn’t an if constexpr make this core constant expression error disappear?
  20. Lifetime of object is over before destructor is called?
  21. Are pointers to non-static member function “formally” not considered pointers
  22. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  23. Observable behavior and undefined behavior — What happens if I don’t call a destructor?
  24. Calling an explicit constructor with a braced-init list: ambiguous or not?
  25. std::tuple memory alignment
  26. Appending std::vector to itself, undefined behavior?
  27. Rvalues, lvalues and formal definitions
  28. Dereferencing one past the end pointer to array type
  29. What is use of the ref-qualifier `const &&`?
  30. Is it safe to memset bool to 0?

Leave a Comment