Shift operator

[satishind Reddy]

i find this question from mock exam.
what is the output displayed by the following programe?
[CODE]
class Question{
public static void main(String args[]){
int n = 7;
n <<= 3;<br /> n = n & n+1 | n+2 ^ n+3 ;<br /> n >>= 2;
System.out.println(n);
}
}
can any one suggest fast way to calculate 'n' value.
I think this type of questions will take more time in exame. Is it possible to get this type questions in real exame.
Regards
Satish

[Anonymous]

Hi Satishind,
First, I can't believe we will have a so complex question at the exam (I'm attending it on Thursday) because operators precedence are difficult to memorise properly. It is always advised to use parentheses to make a code more explicit to the reader.
Anyway, the easiest way to work out the results of binary operations is to express the result in binary form.

    int n = 7;
    <font color="#003F00">
    // n = 4+2+1
    //   = 1*2<sup>2</sup>+1*2<sup>1</sup>+ 1*2<sup>0</sup>
    //   = 00000000000000000000000000000111 (on 32 bits)
    //   = 111 (to simplify)
    </font>
    n <<= 3;
    <font color="#003F00">
    // First, we develop the assignment operator like this:
    // n = n << 3;
    //
    // This is a left shift of 3 bits. To accomplish that,
    // we just add 3 zeros to the right of the binary
    // number.
    // n = n << 3
    //   = 111 << 3
    //   = 111[B]000[/B]
    </font>
    n = n & n+1 | n+2 ^ n+3 ;
    <font color="#003F00">
    // For this one, we have to understand what is called
    // operator's precedence. It specifies the way the
    // compiler evaluates the expression. The first generic
    // rule is that an expression is evaluated left to right
    // when the operators have the same precedence.
    //
    // Here the addition have a higher precedence than binary
    // operations. So the expression is identical to:
    // n = n & (n + 1) | (n + 2) ^ (n + 3)
    //
    // The & (binary and) and the ^ (xor) have a higher
    // precedence than the | (binary or), so
    // n = (n & (n + 1)) | ((n + 2) ^ (n + 3))
    //
    // Which gives in binary form (won't compile ):
    // n = (111000 & (11100 + 1)) | ((11100  + 10) ^ (11100  + 11))
    //   = (111000 & 111001) | (111010 ^111011)
    //   = 111000 | 000010
    //   = 111010
    </font>
    n >>= 2;
    <font color="#003F00">
    // By developing the assignment operator, we get this:
    // n = n >> 2
    //
    // For a signed right shift operation, we simply remove
    // the number of bits from the right (here two),
    // which gives in binary format:
    // n = 111010 >> 2
    //   = 1110
    // 
    // In decimal format, it gives:
    // n = 1*2<sup>3</sup>+1*2<sup>2</sup>+ 1*2<sup>1</sup>
    //   = 8 + 4 + 2
    //   = 14
    </font>
    System.out.println(n);
    // will display 14

Please tell me if this is still unclear.
Regards,
Beno�t

[This message has been edited by Beno�t d'Oncieu (edited October 31, 2000).]