Bitwise and bit shift operators are used to perform bit level operations on integer (int, long, etc) and boolean data. These operators are not commonly used in real life situations.

If you are interested to explore more, visit practical applications of bitwise operations.

The bitwise and bit shift operators available in C# are listed below.

Operator | Operator Name |
---|---|

~ | Bitwise Complement |

& | Bitwise AND |

| | Bitwise OR |

^ | Bitwise Exclusive OR (XOR) |

<< | Bitwise Left Shift |

>> | Bitwise Right Shift |

## Bitwise OR

Bitwise OR operator is represented by `|`

. It performs bitwise OR operation on the corresponding bits of two operands. If either of the bits is `1`

, the result is `1`

. Otherwise the result is `0`

.

If the operands are of type `bool`

, the bitwise OR operation is equivalent to logical OR operation between them.

For Example,

14 = 00001110 (In Binary) 11 = 00001011 (In Binary)

Bitwise `OR`

operation between 14 and 11:

00001110 00001011 -------- 00001111 = 15 (In Decimal)

### Example 1: Bitwise OR

```
using System;
namespace Operator
{
class BitWiseOR
{
public static void Main(string[] args)
{
int firstNumber = 14, secondNumber = 11, result;
result = firstNumber | secondNumber;
Console.WriteLine("{0} | {1} = {2}", firstNumber, secondNumber, result);
}
}
}
```

When we run the program, the output will be:

14 | 11 = 15

## Bitwise AND

Bitwise AND operator is represented by `&`

. It performs bitwise AND operation on the corresponding bits of two operands. If either of the bits is `0`

, the result is `0`

. Otherwise the result is `1`

.

If the operands are of type `bool`

, the bitwise AND operation is equivalent to logical AND operation between them.

For Example,

14 = 00001110 (In Binary) 11 = 00001011 (In Binary)

Bitwise AND operation between 14 and 11:

00001110 00001011 -------- 00001010 = 10 (In Decimal)

### Example 2: Bitwise AND

```
using System;
namespace Operator
{
class BitWiseAND
{
public static void Main(string[] args)
{
int firstNumber = 14, secondNumber = 11, result;
result = firstNumber & secondNumber;
Console.WriteLine("{0} & {1} = {2}", firstNumber, secondNumber, result);
}
}
}
```

When we run the program, the output will be:

14 & 11 = 10

## Bitwise XOR

Bitwise XOR operator is represented by `^`

. It performs bitwise XOR operation on the corresponding bits of two operands. If the corresponding bits are **same**, the result is `0`

. If the corresponding bits are **different**, the result is `1`

.

If the operands are of type `bool`

, the bitwise XOR operation is equivalent to logical XOR operation between them.

For Example,

14 = 00001110 (In Binary) 11 = 00001011 (In Binary)

Bitwise XOR operation between 14 and 11:

00001110 00001011 -------- 00000101 = 5 (In Decimal)

If you want to more about the usage of Bitwise XOR, visit The Magic of XOR

### Example 3: Bitwise XOR

```
using System;
namespace Operator
{
class BitWiseXOR
{
public static void Main(string[] args)
{
int firstNumber = 14, secondNumber = 11, result;
result = firstNumber^secondNumber;
Console.WriteLine("{0} ^ {1} = {2}", firstNumber, secondNumber, result);
}
}
}
```

When we run the program, the output will be:

14 ^ 11 = 5

## Bitwise Complement

Bitwise Complement operator is represented by `~`

. It is a unary operator, i.e. operates on only one operand. The `~`

operator **inverts **each bits i.e. changes 1 to 0 and 0 to 1.

For Example,

26 = 00011010 (In Binary)

Bitwise Complement operation on 26:

~ 00011010 = 11100101 = 229 (In Decimal)

### Example 4: Bitwise Complement

```
using System;
namespace Operator
{
class BitWiseComplement
{
public static void Main(string[] args)
{
int number = 26, result;
result = ~number;
Console.WriteLine("~{0} = {1}", number, result);
}
}
}
```

When we run the program, the output will be:

~26 = -27

We got -`27`

as output when we were expecting `229`

. **Why did this happen?**

It happens because the binary value `11100101`

which we expect to be `229`

is actually a 2's complement representation of `-27`

. Negative numbers in computer are represented in 2's complement representation.

For any integer n, 2's complement of `n`

will be `-(n+1)`

.

Decimal | Binary | 2's Complement |
---|---|---|

0 | 00000000 | -(11111111 + 1) = -00000000 = -0 (In Decimal) |

1 | 00000001 | -(11111110 + 1) = -11111111 = -256 (In Decimal) |

229 | 11100101 | -(00011010 + 1) = -00011011 = -27 |

Overflow values are ignored in 2's complement.

The bitwise complement of `26`

is 229 (in decimal) and the 2's complement of `229`

is `-27`

. Hence the output is `-27`

instead of `229`

.

## Bitwise Left Shift

Bitwise left shift operator is represented by `<<`

. The `<<`

operator shifts a number to the left by a specified number of bits. Zeroes are added to the least significant bits.

In decimal, it is equivalent to

num * 2bits

For Example,

42 = 101010 (In Binary)

Bitwise Lift Shift operation on 42:

42 << 1 = 84 (In binary 1010100) 42 << 2 = 168 (In binary 10101000) 42 << 4 = 672 (In binary 1010100000)

### Example 5: Bitwise Left Shift

```
using System;
namespace Operator
{
class LeftShift
{
public static void Main(string[] args)
{
int number = 42;
Console.WriteLine("{0}<<1 = {1}", number, number<<1);
Console.WriteLine("{0}<<2 = {1}", number, number<<2);
Console.WriteLine("{0}<<4 = {1}", number, number<<4);
}
}
}
```

When we run the program, the output will be:

42<<1 = 84 42<<2 = 168 42<<4 = 672

## Bitwise Right Shift

Bitwise right shift operator is represented by `>>`

. The `>>`

operator shifts a number to the right by a specified number of bits. The first operand is shifted to right by the number of bits specified by second operand.

In decimal, it is equivalent to

floor(num / 2bits)

For Example,

42 = 101010 (In Binary)

Bitwise Lift Shift operation on 42:

42 >> 1 = 21 (In binary 010101) 42 >> 2 = 10 (In binary 001010) 42 >> 4 = 2 (In binary 000010)

### Example 6: Bitwise Right Shift

```
using System;
namespace Operator
{
class LeftShift
{
public static void Main(string[] args)
{
int number = 42;
Console.WriteLine("{0}>>1 = {1}", number, number>>1);
Console.WriteLine("{0}>>2 = {1}", number, number>>2);
Console.WriteLine("{0}>>4 = {1}", number, number>>4);
}
}
}
```

When we run the program, the output will be:

42>>1 = 21 42>>2 = 10 42>>4 = 2