Well, next time write:
x = ++x;
I've pretty much trained myself to never use post-increment unless a statement is incorrect without it, and even then I'm unhappy if the statement has any other side effect at all (unless the entire idiom is lifted straight from K&R, and then I ponder why the code is rolling its own iterator loop.)
Post-increment can fail in interesting ways (yes, those darn sequence points). In addition, when using a template metaprogramming library, post-increment can trigger a large state copy that an unwary programmer doesn't expect. It can be horrifically less efficient.
On the other hand, the ternary operator (even a compound ternary operator) has FAR FEWER semantic ass-bites that plain old post-increment.
Post-increment: Visually familiar, but badly behaved.
Ternary: Visually unfamiliar (to some), but well behaved.
In the STL context, an important property of the ternary operator is that you don't have to declare the return type of the expression (whereas with an if/else assignment into an intermediate variable, you do). Maybe this is less important now with better "auto" support.
A prudent ?: will also keep you on the straight and narrow with respect to the ODR. You can avoid re-typing shared sub-expressions. Anyone ever debugged a program where consecutive lines of code intended to contain an identical subexpression, but actually didn't? No, I didn't think so.
Really, when someone complains about the ?: operator as some form of diabolical trickery, I flip the bozo bit. But you just can't get a programmer to embrace it for The Right Reasons who won't first master sequence points and the horror show of post-increment.
Grasshopper, this is your debugger.
Debugger, this is your new grasshopper. Enjoy your tasty meal.
