You appear to be defining "order of operations" to be "the order in which side effects from evaluating an expression become visible", instead of the more common meaning of "the order in which you apply substitution rules, defining operator precedence".  

You might want to substitute a different phrase to avoid confusion with the more common meaning.  For example, "evaluation order vs precedence" -- or even the slightly humorous "order in which operations take place vs order of operations", which plays on different meanings of "order "and "operations"

Or maybe I'm the only who was confused by the "X vs X" title.

Footnote: Raymond Chen used the phrase "order of evaluation", which might have been what you intended.  That sounds better than what I suggested.  Citation: http://blogs.msdn.com/oldnewthing/archive/2007/08/14/4374222.aspx

Eric himself used "order of evaluation" in the linked article.

I like to think of the postfix operators as first incrementing/decrementing, then returning the original value. Pretty easy concept to grasp, no magic here.

(In C++ this is pretty obvious, because that's just what you do if you overloaded the ++ operator.)

The one that confused me is this C# code which gives different results in C & C#

int[] data={11,22,33};int i=1;data[i++]=data[i]+5;

I couldn't find a bit in the C# spec that said anything about when increment should happen. I had presumed that the rvalue would be evaluated first followed by the lvalue.

Any ideas where I missed it.

Related question on stackoverflo.com: http://stackoverflow.com/questions/1260227/int-arr0-int-value-arrarr0-value-1

@Peter Ibbotson: The statement:

 data[i++] = data[i] + 5;

isn't valid C, as the order of evaluation is implementation defined (or undefined, I forget which).  It may work, it might not work, and the behavior may change between compiler vendors (and/or between different compiler versions from the same vendor).

In short, don't do that in C and C++.

It's fine in C# (and Java, among others) because C# explicitly specifies order of evaluation.  C and C++ do not.

I really recommend that you see the question on stackoverflow http://stackoverflow.com/questions/1260227/int-arr0-int-value-arrarr0-value-1 I posted this question after I read the article. I always used to think that post increment happens after everything else. I stand corrected, post increment happens IMMEDIATELY. Yes! The variable to be incremented is incremented immediately, but it's old value is still used for evaluating the next expression. If that next expression dereferences the value of the variable (the incremented value) it will use the incremented value not the old value. e.g.

int x=0, y=0;

int z = x+ (y++) +y;

what will happen first is that y will be incremented (to be 1 in this case) then it's value will be stored (somewhere a temp variable for example) afterwards we use the old value (stored in the temp) to evaluate the next expression (adding x to whatever the return value of (y++) which is 0 as mentioned previously)  this expression will now return 0 (0 + 0 =0) we take this value (0) and use it to evaluate the next part of the expression (adding y). we add 0 to y (what is the value of y now? Yes! It's 1). So the result of z will be 0 + 1 = 1.

even more fun, just use LinqPad and run the following.

int i = 0;

string.Format("{0} - {1} - {2}", i, i++, i++).Dump("i-i-i");

i.Dump("i-After");

gives you

▪ i-i-i

0 - 0 - 1

▪ i-After

2

We tried this exact experiment once in college, as a survey of C compilers. Some gave 0, some gave 1, it was quite interesting. We also tried:

int x = 0;

int value1 = x++ + ++x;

This wasn't totally reliable either. It gives either 1 or 2, for much the same reason. (This should be 2 in C#.) Combining these two experiments we constructed a program that gave anything from 0 to 3, depending on how the compiler was feeling. Unspecified semantics are great!