--
We had found precedence vs. order of evaluation and Re: *p++ great posts by Steve Summit in comp.lang.c. Here is summary of his posts in term of Java:
The important thing about precedence is not that it tells us in what order things will be evaluated. The important thing about precedence is that it tells us which operators are matched up with which operands. The precedence determines which operations will be performed first and not the order of operand evaluation.
The precedence can affect or influence order of evaluation. Now let's start looking at all of the ways that order of evaluation is determined by things other than precedence. In Java, operands are always evaluated from left to right.
For example, multiplication and division are done before addition and subtraction, because multiplication and division have higher precedence than addition and subtraction. Therefore, a + b *c is the same as a + (b*c), not (a+b)*c. The statement was probably made that "the multiplication happens first, before the addition, because multiplication has higher precedence than addition". And having heard an explanation like that, it's all too easy to come away with the impression that precedence controls order of evaluation, and it's also all too easy to get into trouble later when considering an expression like x = ++a + a++, where the precedence of post-fix increment does not control, doesn't even come close to controlling, the aspect of evaluation order that you're interested in.
If we look at the expression a + b * c very carefully, the key aspect explained by precedence is that the multiplication operator is applied to the operands b and c, and the addition operator is applied to a and the result of the multiplication. (Notice that we said "and", not "and then"). Here, although there's definitely an order of evaluation issue, and although the order of evaluation is apparently influenced by the precedence somehow, the influence is actually not a direct one. The real constraint on the order of evaluation is that we obviously can't complete an addition which involves the result of the multiplication until we've got the result of that multiplication. So we're probably going to have to do the multiplication first and the addition second, but this is mostly a consequence of causality, not precedence.
Another way to think about precedence is that it controls how the compiler parses expressions. Let's look at the expression
x = a + b*c, which can be parenthesized as x = a + (b *c). Instead of parentheses, we can draw a "parse tree":
This data flow diagram shows another way to think about expression evaluation. Boxes represent values in memory, ovals represent operations, and arrows show the direction of data flow. The assignment operator ("=") is treated as an operator with low precedence by the compiler, but from a data flow point of view it only moves data so it's represented as an arrow, not an operation.
Once it has determined the parse tree, the compiler sets about emitting instructions (in some order) which will implement that parse tree. The shape of the tree may determine the ordering of some of the instructions, and precedence affects the shape of the tree. But the order of some operations may not even be strictly determined by the shape of the tree, let alone the precedence. So while precedence certainly has an influence on order of evaluation, precedence does not "determine" order of evaluation.
For an other example,
class Program {
public static void main(String[] args) {
int a = 1;
int x = ++a + a++;
System.out.println("Result is " + x);
}
}The result is 4. That means that ++a will be evaluated first and then evaluate a++.
Comments
Post a Comment