I am not getting the logic of the following oeperator precedence.

c= a++ + a++ + a; (where a is 10)
The output of c is coming 30, whereas according to my calculation it is coming 33.
What I calculate is
c = 10 + 11 + 12;
Can anybody explain the process how the expression is giving 30?

I get the same results as you.

its undefined behaviour, the result could be anything

http://www.research.att.com/~bs/bs_faq2.ht...valuation-order

doing a++, adds 1 to the variable a after the statement I thought? No, hmm... ok somethings fucked up with C++ here.

This post has been edited by TheMagnitude: 9 Mar, 2008 - 12:13 PM

I thought the same as TheMagnitude. I thought that the variable++ operatoor would add 1 to it after the operation, whereas ++variable, adds it before

Well, as Bench pointed out, this is undefined behavior, but lets think about why.

Technically speaking the post-increment operator returns the current value of the variable, then increments the value. So, given a=10 then the expression:
c = a++ + a++ + a; should evaluate as, 10 + 11 + 12, the 10, because that if the current value of a, but a gets incremented, so the next a is 11, and then incremented, and finally a= 12, c = 33.

Some compilers may in fact return this value sometimes. The problem is that different compilers will evaluate the expression in different ways. For example it may be evaluated from right to left giving 11 + 10 + 10. Many compilers will not increment the value until after the expression has been evaluated, which yields, 10 + 10 + 10, and then a becoms 12. The point is, that there are no rules defining how the compiler must evaluate this type of expression.

So... to reiterate:

A good explanation. Thanks. But shall we assume that this is a drawback in C++? If there is no specific rule then how can we write any expression logicaly?

There's nothing stopping you checking the compiler's documentation, and taking advantage of compiler-specific behaviour, but I'd question why you wanted to do it in the first place. Its better for everybody if you break it up into smaller steps across multiple lines, instead of trying to write ugly "clever" code which would otherwise make for difficult reading.

I believe the reason the C++ standard doesn't specify evaluation order, is simply because it places an unnecessary restriction upon compiler vendors in the way which compilers are written, and a standard defined evaluation order wouldn't add anything useful to the language anyway, as far as I can see (Since compilers which do differ in their implementations are just as capable as each another).

Thanks a lot. I am satisfied with your logic.
take care