## Bitwise Operators

### Bits and Bytes

We know that memory is made up of bits and bytes, and we should know what they are by now.
• A bit is the smallest unit of storage in a computer.  It stores a 0 or a 1.
• A byte consists of 8 bits, and is special because it is usually the smallest unit of directly addressible storage.  This means - it is the smallest item that we can create a variable out of.  Addresses in memory are usually applied to bytes.
The smallest built-in data type is the char, which on most systems today is 1 byte.
So...  what if we want to access individual bits?  Is this possible?  Yes -- but not directly.  We must use the bitwise operators to act at the bit level.

Caution:  Bitwise operations may be machine-dependent, to an extent, because they rely on the way that the bits are arranged in memory.  Some machines may not store all built-in data types in the same formats.  Most machines, however, tend to use a pretty standard representation for integer types, called "2's Complement" format.

### The Bitwise Operators

Operator Name Arity Description
& bitwise AND binary Similar to the && operator, but on a bit-by-bit basis.  Bits in the result set to 1 if corresponding operand bits are both 1, and set to 0 otherwise
| bitwise OR (inclusive) binary Similar to the || operator, but on a bit-by-bit basis.  Bits in the result set to 1 if at least one of the corresponding bits in the two operands is 1.  0 otherwise.
^ bitwise exclusive OR binary Bits in the result set to 1 if exactly one of the corresponding bits in the two operands is 1.  Result bit set to 0 if both corresponding bits in operands are the same.
<< left shift binary Shifts the bits of the first operand to the left, by the number of bits specified in the second operand.  Right fill with 0 bits.
>> right shift binary Shifts the bits of the first operand to the right, by the number of bits specified in the second operand.  Left fill depends on the machine.  Usually based on the sign (fill with 0's for positive numbers, 1's for negatives).
~ complement unary Flips the bits in the operand.  Similar to negation.  (All 1's become 0's, and all 0's become 1's).

In addition to these, there are also shortcut assignment operators, like with the arithmetic operators.

```  x &= y      means x = x & y
x |= y      means x = x | y
x ^= y      means x = x ^ y
x <<= y     means x = x << y
x >>= y     means x = x >> y
```

### Examples

Suppose we have the following code:
```  short x = 6891;
short y = 11318;
```
And let's assume that we are using a machine in which a short is 2 bytes (which is 16 bits). The binary representations of x and y, then, are:
```     x:  00011010 11101011
y:  00101100 00110110
```
Suppose we did the operation (x & y). Then we perform the AND operation on the individual bits:
```     x:  00011010 11101011
y:  00101100 00110110
--------------------------
result:  00001000 00100010    // this is the value 2082

```
Here is the bitwise OR operation (x | y):
```     x:  00011010 11101011
y:  00101100 00110110
--------------------------
result:  00111110 11111111    // this is the value 16127

```
Here is the bitwise exclusive OR operation (x ^ y):
```     x:  00011010 11101011
y:  00101100 00110110
--------------------------
result:  00110110 11011101    // this is the value 14045

```
Here is a bitwise left shift, performed on x (x << 2):
```      x:  00011010 11101011
---------------------------
shifted:  01101011 10101100    // this is the value 27564

```
Here is a bitwise right shift, performed on y (y >> 4):
```      y:  00101100 00110110
---------------------------
shifted:  00000010 11000011    // this is the value 707

```
And here is the complement of x (~x)
```      x:  00011010 11101011
---------------------------
~x:  11100101 00010100    // this is the value -6892

```