Precedence and Associativity code snippet

Question

Look at this code snippet and assume the value of i is 2:
((k = (++i)) + (j = (2 * (++i))))We have the pre-increment operator showing up twice and that operator is the highest level precedence in this example. Next in line as far as precedence goes is the multiply operator. So what I did was I went to the far right and raised i from 2 to 3
and then I figured since multiplication is the next in level of precedence I multiplied 3 * 2 to get 6.
But I guess that's not the correct way to evaluate this. The author said when you have two operators that are of the same level of precedence, Java uses associativity rules to "break the tie."
So I guess the correct thing to do is first increment i from 2 to 3 at the far left and then assign that to k.
I'm just a bit confused I guess. I thought step 1 would be to go to the far right and increment i from 2 to 3. Then step 2 would be to carry out the multiply operation.
Now the increment operator and the assignment operator are right associative. So the increment operator binds to variable i and the assignment operator binds to the result of incrementing i.
But I don't see the connection between being right associative and proceeding to evaluate expressions from left to right. I'm still not completely understanding why we evaluate the far left expression first and not do the far right one first.
Edited by: 357mag on Jun 6, 2010 7:46 PM
Edited by: 357mag on Jun 6, 2010 7:48 PM
Edited by: 357mag on Jun 6, 2010 7:49 PM

Answer 1

Savitch said Java first does binding; that is it fully parenthesizes the expression using precedence and associativity rules. Then it evaluates expressions left to right.If that's what he says he is wrong. There is no such thing as 'binding; that is it fully parenthesizes the expression using precedence and associativity rules,' and I've already shown that 'evaluates expressions left to right' isn't correct either. See also the JLS, where none of this fantasy is mentioned. Compilers don't 'fully parenthesize' expressions. They parse them according to the grammar, which defines precedence and associativity; then they evaluate the operators in order of precedence, evaluating the operands of each operator in left-to-right order.
Walter Savitch is apparently a professor of CS and should know better than that. I'd like to see what he really said.
Since multiplication has a higher level of precedence than addition we perform the multiply operation first.Of course we do. That's not the point at issue.
Java is actually doing this:
d = a + (b * c)
That is the point at issue. This is incorrect. Java isn't 'actually doing this' at all. That's just begging the question. There is no compilation step that corresponds to the insertion of those parentheses. What is actually happening is that operator precedence dictates that the multiplication be evaluated before the addition.
As I said above, to a compiler writer, () is just another operator. Explaining operator precedence in terms of parentheses is putting the cart before the horse. It works the other way round.
Answer is 7Of course it is. That's not in dispute.
It's like the BODMAS you learned in 3rd grade.
The way it is actually done is (a) turning the expression into a parse tree, with the operators already in the correct place due to precedence, as dictated by the grammar, and (b) outputting a Reverse-Polish representation of the expression, which in the above case would look like this:
PUSH 1
PUSH 2
PUSH 3
MULTIPLY ; pop the top two elements on the stack, multiply them, and push the result
ADD ; pop the top two elements on the stack, add them, and push the result.
No parentheses there.