Bit Operators (<<, >>, &, ^, |, ~)

The << and >> operators shift an integer left or right respectively. The operands must have integer type, and all automatic promotions are performed for each operand. For example, the program fragment

short int  to_the_left = 53, to_the_right = 53;
short int  left_shifted_result, right_shifted_result;
 
left_shifted_result = to_the_left << 2;
right_shifted_result  = to_the_right >> 2;

sets left_shifted_result to 212 and right_shifted_result to 13. The results are clearer in binary:

   base 2          base 10
0000000000110101     53
0000000011010100    212  /* 53 shifted left 2 bits  */
0000000000001101     13  /* 53 shifted right 2 bits */

Shifting to the left is equivalent to multiplying by powers of two:

  x << y is equivalent to x * 2y.

Shifting non-negative integers to the right is equivalent to dividing by powers of 2:

  x >> y is equivalent to x / 2y.

The << operator always fills the vacated rightmost bits with zeros. If exp1 is unsigned, the >> operator fills the vacated leftmost bits with zeros. If exp1 is signed, then >> fills the leftmost bits with ones (if the sign bit is 1) or zeros (if the sign bit is 0). In other words, if exp1 is signed, the two bit-shift operators preserve its sign.

	NOTE: Not all compilers preserve the sign bit when doing bit-shift operations on signed integers. The K&R language definition and the ANSI standard make this behavior implementation-defined.

Make sure that the right operand is not larger than the size of the object being shifted. For example, the following produces unpredictable and nonportable results because ints have fewer than 50 bits:

10 >> 50

You will also get nonportable results if the shift count (the second operand) is a negative value.

The logical bitwise operators are similar to the Boolean operators, except that they operate on every bit in the operand(s). For instance, the bitwise AND operator (&) compares each bit of the left operand to the corresponding bit in the righthand operand. If both bits are 1, a 1 is placed at that bit position in the result. Otherwise, a 0 is placed at that bit position.