Is this operation properly sequenced?

Question

In the following code ^{excerpt from a larger piece of code presented}

void func(int* usedNum, int wher) {
    *usedNum = *usedNum + 1 > wher ? ++(*usedNum) : wher + 1; 
}

int main(void) {
   int a = 11, b = 2; 
   func(&a, b); 
}

a warning is emitted

 warning: operation on '* usedNum' may be undefined [-Wsequence-point]
 *usedNum = *usedNum + 1 > wher ? ++(*usedNum) : wher + 1; 

Is there a problem with the code?

My source of doubt was this and the part where it says

The sequence points in the logical expressions such as && and || and ternary operator ?: and the comma operator mean that the left hand side operand is evaluated before the right hand side operand. These few operands are the only operands in C++ that introduce sequence points.

tl;dr

For those that find torturing to read through the comments: The initial question was not properly posed and it would be unfair to create misconceptions. My view on the topic had two sides

1. The ternary operator does not mess up (in an unexpected way) the sequence points (which holds, the two branches are sequenced in every version of C,C++ - see the link provided)

2. Is x = ++x the problem? As seen in the coliru link, we compile for c++14. There the operation is well defined (references on the comments), but older versions of c++ and c view this as undefined. So why is there a warning?

Answers focus both in C and C++; this is a good link. Lastly the C tag was there initially (my bad) and can't be removed because existing upvoted answers refer to it

Answer 1

When the condition is true, it is the equivalent of saying x = ++x. In C, and versions of C++ prior to C++11, this constitutes a modification and a read of x without an intervening sequence point and therefore is undefined behaviour if the truthy branch is followed. From C++11 onwards, x = ++x is sequenced and well defined.

---

Edit To clarify some issues from comments.

1) this would be well defined in all C and C++ standards:

x = (++x, x); // RHS evaluates to x after increment

because the expression in the parentheses involves the comma operator, which introduce a sequence point between the evaluation of its operands. So the whole expression on the RHS evaluates to x after an increment. But the code in your question does not involve the comma operator.

2) The ternary operator introduces a sequence point

It is a sequence point between the condition and the two branches. But this doesn't introduce a sequence point between either branch and the assignment.

Answer 2

The warning you are getting is probably due to the fact that you are compiling your code in c++03 mode or older. In C99 and C++03, expression

x = ++x;

invokes undefined behavior. The reason is that between two sequence points an object can't modify more than once.

This rule is changed in C11 and C++11. According to C11, the rule is as follows:

C11:6.5 Expressions:

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

When *usedNum + 1 > wher will be true, then

*usedNum = *usedNum + 1 > wher ? ++(*usedNum) : wher + 1;   

would be equivalent to

*usedNum = ++(*usedNum);  

and according to new rule this is well defined in C++11 this is because the side effect by pre ++ is sequenced before the side effect by = operator. Read this answer for more detailed explanation.

But the same expression *usedNum = ++(*usedNum); invokes undefined behavior in C11. The reason is that there is no guarantee that side effect by = operator is sequenced after the side effect of pre ++ operator.

---

Note: In the expression

a = x++ ? x++ : 0; 

there is sequence point after the first x++ and hence behavior is well defined. Same is true for

x = (++x, x);  

because there is a sequence point between the evaluation of left and right operand and hence side effect is sequenced.