Operator precedence and associativity confusion........

[Amit Das]

Hi all,

i was just trying to understand how operatoe precedence and associativity works by going through this link which says well about it....according to me.

So i tried a question from K&B buk Chap 3 page 200(ques no. 12)

 
12. Given the following,
1. class BoolArray {
2.      boolean [] b = new boolean[3];
3.      int count = 0;
4.
5.      void set(boolean [] x, int i) {
6.            x[i] = true;
7.            ++count;
8.      }
9.
10.     public static void main(String [] args) {
11.           BoolArray ba = new BoolArray();
12.           ba.set(ba.b, 0);
13.           ba.set(ba.b, 2);
14.           ba.test();
15.     }
16.
17.     void test() {
18.           [B]if ( b[0] && b[1] | b[2]  //How is this evaluated????)[/B]
19.           count++;
20.           if ( b[1] && b[(++count - 2)] )
21.           count += 7;
22.           System.out.println("count = " + count);
23.     }
24. }

what is the result?
A. count = 0
B. count = 2
C. count = 3
D. count = 4
E. count = 10
F. count = 11


well everything goes fine but lin 18 i find some problem to evalute the result og the expression.....need help...
well after going through that link's content i see that logical OR(|) has higher precedence than conditional AND(&&).....right???
so i proceed like......if( b[0] && ( b[1] | b[2] ) )
which actually gives me wrong answer, according to the buk....it has been evaluated as if( (b[0] && b[1] ) | b[2] ) to get the given ans....

where does operator precedence comes to play here .....??
is it sth related to operator associativity???well can someone, with an illustration, bother to explain me this thing(associativity ....prcedence). I'll be really thankful to 'em......

one more doubt how is this evaluated by the compiler (i+++j+++++z)
assuming everythings properly initilized say to 0 and all are int primitives

anyone.......

thanx
amit

[vidya sagar]

if ( b[0] && b[1] | b[2] //How is this evaluated???)[

Hi Amit

logical OR(|) has higher precedence than conditional AND(&&).....right???

yes u r correct

When JVM interprets this line by seeing logical OR(|) it assumes left side of the OR operator as one set and right side of the operator as another set
so it evaluates in this fashion

( (b[0] && b[1] ) | b[2] )

one more doubt how is this evaluated by the compiler (i+++j+++++z)
assuming everythings properly initilized say to 0 and all are int primitives

whenever JVM see the first + operator it assumes ordinary unary plus,but if it see another + near by it assumes as increment operator.

so the code becomes

i++ + j++ + ++z

After that it will take it as unary plus(suppose if there is one more plus sign between j and i it throws error)

hope now U R clear

[Rohan Kayan]

logical OR(|) has higher precedence than conditional AND(&&).....right???

yes u r correct

When JVM interprets this line by seeing logical OR(|) it assumes left side of the OR operator as one set and right side of the operator as another set
so it evaluates in this fashion

( (b[0] && b[1] ) | b[2] )

Hi Vidya ,
From your point of view if we are evaluating

a+ b * c
then JVM should interpret it as (a + b ) * c as * has higher precedence and + .
But it doesn't happen like this .

[Joe Sondow]

Originally posted by vidya sagar:


When JVM interprets this line by seeing logical OR(|) it assumes left side of the OR operator as one set and right side of the operator as another set
so it evaluates in this fashion

( (b[0] && b[1] ) | b[2] )

That's actually not correct.

If that were true, then the left side of | would be evaluated, and then the right side of | would be evaluated, since | always evaluates both sides. However, this program demonstrates that that is not what is happening (see Case 4):

public class Oper {
    public static void main(String[] args)
    {
        // CASE 1
        int a1=0, b1=0, c1=0;
        boolean r1 = ++a1==1 || ++b1==1 & ++c1==9;
        System.out.println(
            "a1=" + a1 + ", b1=" + b1 + ", c1=" + c1 + ", " + r1 +
            ", Case 1: true || true & false" );
 
        // CASE 2
        int a2=0, b2=0, c2=0;
        boolean r2 = ++a2==1 || (++b2==1 & ++c2==9);
        System.out.println(
            "a2=" + a2 + ", b2=" + b2 + ", c2=" + c2 + ", " + r2 +
            ", Case 2: true || (true & false)" );
 
        // CASE 3
        int a3=0, b3=0, c3=0;
        boolean r3 = (++a3==1 || ++b3==1) & ++c3==9;
        System.out.println(
            "a3=" + a3 + ", b3=" + b3 + ", c3=" + c3 + ", " + r3 +
            ", Case 3: (true || true) & false" );
 
        System.out.println();
 
        [B]// CASE 4[/B]
        int a4=0, b4=0, c4=0;
        boolean r4 = [B]++a4==9 && ++b4==1 | ++c4==1[/B];
        System.out.println(
            "a4=" + a4 + ", b4=" + b4 + ", c4=" + c4 + ", " + r4 +
            ", Case 4: false && true | true" );
 
        // CASE 5
        int a5=0, b5=0, c5=0;
        boolean r5 = ++a5==9 && (++b5==1 | ++c5==1);
        System.out.println(
            "a5=" + a5 + ", b5=" + b5 + ", c5=" + c5 + ", " + r5 +
            ", Case 5: false && (true | true)" );
 
        // CASE 6
        int a6=0, b6=0, c6=0;
        boolean r6 = (++a6==9 && ++b6==1) | ++c6==1;
        System.out.println(
            "a6=" + a6 + ", b6=" + b6 + ", c6=" + c6 + ", " + r6 +
            ", Case 6: (false && true) | true" );
    }
}

The output is:
a1=1, b1=0, c1=0, true, Case 1: true || true & false
a2=1, b2=0, c2=0, true, Case 2: true || (true & false)
a3=1, b3=0, c3=1, false, Case 3: (true || true) & false

a4=1, b4=0, c4=0, false, Case 4: false && true | true
a5=1, b5=0, c5=0, false, Case 5: false && (true | true)
a6=1, b6=0, c6=1, true, Case 6: (false && true) | true

The results of case 1 and case 2 are identical, and the results of case 4 and case 5 are identical. After a short-circuit operator, the remaining parts of the expression are not evaluated at all, as shown by the fact that the b and c variables in those cases were not incremented.

In case 4, there is an expression
++a4==9 && ++b4==1 | ++c4==1
in which neither ++b4==1 nor ++c4==1 gets evaluated, despite the fact that the | operator always evaluates both sides before returning a result. This shows that evaluation runs left-to-right until the && short-circuit operator determines that no more evaluation is necessary (because the left side of && was false). The rest of the expression is ignored, and false is returned.

[vidya sagar]

Hi joe

In the case 1 why b value is not printing one,++ operatore has higher precedence than || (to my knowledge)

can u explain it???

[Joe Sondow]

The reason is that the rules of precedence do not apply the same way when using short-circuit operators ( && and || ).

In an expression with a short-circuit OR (||), if the left-hand side of the operator evaluates to true, then the right-hand side does not get evaluated.

In an expression with a short-circuit AND (&&), if the left-hand side of the operator evaluates to false, then the right-hand side does not get evaluated.

If a part of the expression does not get evaluated, then any side-effects of that part of the expression will not occur. This includes incrementing variables. Because the right-hand side of the expression does not get evaluated, the ++ operation never occurs.