Thread: a+++b

Hello all,

This is probably a trivially easy question, but here goes anyway:

How or why do C compilers know that the expression a+++b evaluates as (a++)+ b?

In the expression a+(++b), the prefix increment operator has a higher precedence than the binary + operator, which suggests to me that the parentheses are unnecessary and that a+(++b) too could be rewritten as a+++b. Also, associativity would appear to me to be irrelevant here, since we are dealing with operators of different precedence, which in itself should determine the sequence in which the operations are carried out.

Clearly I am missing something here but I have no idea what. I have been right through K&R and can't find any help there.

Sorry if this seems like a stupid question; I have only been learning C for a few weeks.

So does that mean that to comply with the standard you must use parentheses?

These gentlemen don't appear to think there is anything wrong with the expression without parentheses:

http://publications.gbdirect.co.uk/c...rithmetic.html


"Because the unary operators have very high precedence, you can work out what they do before worrying about the other operators. One thing to watch out for is the way that ++ and -- can be before or after their operands; the expression

a + -b++ + c

has two unary operators applied to b. The unary operators all associate right to left, so although the - comes first when you read the expression, it really parenthesizes (for clarity) like this:

a + -(b++) + c"

Crappy code = crappy results.

Originally Posted by Elysia

If you use more than one number and perform operations such as -, ++, -- with or without parenthesises, the result is undefined. The end.
The problem isn't about which operators goes first, but because the compiler is not required to finish the line is linear order.
If it looks like a b c, then the compiler can finish c first, then a and then b. But some other compiler may do it a, b, c. So the result is undefined.

I get your point, but in my example a+++b there are only two operands, and the question is surely not "what order should be operators be executed in?", but "what are the operators?"

Anyhow, if the answer is simply that this is crappy / non-standard code and therefore there is no definite answer to the question, I can accept that.

This strikes me as a deficiency in the language then: We have an expression that in itself is (or at least may be) meaningful and evaluable but is possibly uncompilable simply because the C tokens are themselves not distinguishable. If the increment operator were denoted by, say, § rather than ++, then you would have either a§+b or a+§b and no ambiguity.

This is rather disillusioning...

Even if the compiler could read it properly, I'm sure Humans couldn't.
If it was even like this I could understand it (although it would be easy to miss-read if I didn't have my coffee yet):

Code:

a + ++b or a++ + b

There's a reason spaces were invented.

Order of operation. As the parser reads the equation it sees

a ok we are operating on the variable a
a++ ok we are incrementing the variable a after this operation

+b ok we are adign b to the equation.

But surely the compiler doesn't recogize white space?!

And I don't see that this is an problem of order of evaluation.

If the code were unambiguous, it wouldn't matter what order the terms were evaluated in, since they don't affect each other.