Quote:Original post by Trienco

Quote:Original post by SiCrane
Another example is a function call: all arguments to the function call must be evaluated before the function is actually called. So if you have foo(++a, ++b), you know that both ++a and ++b were both evaluated before foo() was called.

Just to add one more: while you can be sure that they will be evaluated before the function call, you can't be sure about the order. So doing something like foo(a,++a) and relying on a left to right order isn't a good idea (and real fun to debug when differently optimized builds or builds from different compilers behave differently).

Quote:Original post by SiCrane
C++ has the concept of sequence points. A sequence point is basically a point in the code where everything before it has to have finished evaluating before execution proceeds any further. For example: the end of a statement is a sequence point. So this is well defined:
++a;
++a;
Even though this is not:
++a + ++a;

Another example is a function call: all arguments to the function call must be evaluated before the function is actually called. So if you have foo(++a, ++b), you know that both ++a and ++b were both evaluated before foo() was called.

Logical and and or, the ternary operator and the comma operator also have a sequence point after the first expression. So in A && B, A || B, A , B and A ? B : C the A has to finish evaluating, with all its side effects before B (or C) is evaluated. So ++a && ++a has well defined behaviour even though ++a + ++a</t> doesn't.

Quote:Original post by ph33r

Quote:Original post by Trienco

Quote:Original post by SiCrane
Another example is a function call: all arguments to the function call must be evaluated before the function is actually called. So if you have foo(++a, ++b), you know that both ++a and ++b were both evaluated before foo() was called.

Just to add one more: while you can be sure that they will be evaluated before the function call, you can't be sure about the order. So doing something like foo(a,++a) and relying on a left to right order isn't a good idea (and real fun to debug when differently optimized builds or builds from different compilers behave differently).

I'm assuming the order its evaluated is based on the calling convention of that function. I'm sure this isn't guarenteed in the standard but it makes sense from a compiler point of view.

inc ainc binc cpush apush bpush c