**Bitwise Operators** are used to perform **bit-level operation**s in C programming. They are also used for **shifting of bits** in the program.

**There are six types of bitwise operators.**

## 1. Bitwise AND operator `&`

In the Bitwise AND operation the output of the Bitwise AND operator will be 1 if both the bits are 1. If any of the two bits are 0 then the output will be 0.

**For Example:**

**Consider A = 12 and B = 10 then Bitwise AND operation (A&B) will be**

```
Binary of 12 is 00001100
Binary of 10 is 00001010
(A&B) will be
00001100
& 00001010
----------
00001000 = 8
Therefore (A&B) = 8
```

The Bitwise AND Operation is based on the following truth table for two bits:

### Program example of Bitwise AND Operator

```
//An example of Bitwise AND Operator
#include<stdio.h>
int main()
{
int A = 12, B = 10;
printf("Consider A = 12 and B = 10 \n");
printf("Bitwise AND Operation (A&B) = %d\n",(A&B));
return 0;
}
```

### Output

```
Consider A = 12 and B = 10
Bitwise AND Operation (A&B) = 8
```

## 2. Bitwise OR operator `|`

In the Bitwise OR operation the output of the Bitwise OR operator will be 1 if any of the bit is 1. If both of bits are 0 then the output will be 0.

**For Example:**

**Consider A = 12 and B = 10 then Bitwise OR operation (A|B) will be**

```
Binary of 12 is 00001100
Binary of 10 is 00001010
(A|B) will be
00001100
| 00001010
----------
00001110 = 14
Therefore (A|B) = 14
```

The Bitwise OR Operation is based on the following truth table for two bits:

### Program example of Bitwise OR Operator

```
//An example of Bitwise OR Operator
#include<stdio.h>
int main()
{
int A = 12, B = 10;
printf("Consider A = 12 and B = 10 \n");
printf("Bitwise OR Operation (A|B) = %d\n",(A|B));
return 0;
}
```

### Output

```
Consider A = 12 and B = 10
Bitwise OR Operation (A|B) = 14
```

## 3. Bitwise XOR operator `^`

In the Bitwise XOR operation the output of the Bitwise XOR operator will be 1 if both of the bits are opposite. If both of bits are same then the output will be 0.

**For Example:**

**Consider A = 12 and B = 10 then Bitwise XOR operation (A^B) will be**

```
Binary of 12 is 00001100
Binary of 10 is 00001010
(A^B) will be
00001100
^ 00001010
----------
00000110 = 6
Therefore (A^B) = 6
```

The Bitwise XOR Operation is based on the following truth table for two bits:

### Program example of Bitwise XOR Operator

```
//An example of Bitwise XOR Operator
#include<stdio.h>
int main()
{
int A = 12, B = 10;
printf("Consider A = 12 and B = 10 \n");
printf("Bitwise XOR Operation (A^B) = %d\n",(A^B));
return 0;
}
```

### Output

```
Consider A = 12 and B = 10
Bitwise XOR Operation (A^B) = 6
```

## 4. Bitwise complement operator `~`

The Bitwise complement operator `~`

is a unary operator. In the Bitwise complement operation the output of the Bitwise complement operator will be 1 if bit is 0 and output will be 0 if the bit is 1. But he Bitwise complement operation is abit twisted. It uses two’s complement system.

**For Example:**

**Consider A = 12 then Bitwise Complement operation (~A) will be**

```
Binary of 12 is 00001100
(~A) will be
~ 00001100
----------
11110011 = 243 in decimal but the computer
stores integers in 2's
complement form so
(11110011) would be -13
To understand this,
Look at the two's complement of 13 below
Binary of 13 is 00001101
One's complement of 13 is 11110010
Two's complement of 13 is 11110011 which is (-13)
Therefore (~A) = -13
```

The Bitwise Complement Operation is based on the following truth table:

### Program example of Bitwise Complement Operator

```
//An example of Bitwise Complement Operator
#include<stdio.h>
int main()
{
int A = 12;
printf("Consider A = 12 \n");
printf("Bitwise Complement Operation (~A) = %d\n",(~A));
return 0;
}
```

## Output

```
Consider A = 12
Bitwise Complement Operation (~A) = -13
```

## 5. Bitwise Shift Right `>>`

Bitwise Shift Right is used to shift the binary bits right by specific position.

**For example:**

**Let a decimal number be 12.**

**And its binary is 00001100**

Now if we shift bits of 12 right by 1 i.e. (12 » 1) then it would results 6.

**Let’s take another example**

**Consider a decimal number be 36.**

**And its binary is 00100100.**

Now if we shift bits of 36 right by 2 i.e (36 » 2) then it would results 9.

This concludes that if `m`

is the number and `n`

is the bits to shift right the it follows the rule `m/2^n`

.

### Program example of Bitwise Shift Right Operator

```
//An example of Bitwise Shift Right Operator
#include<stdio.h>
int main()
{
int A = 12, B = 36;
printf("Consider A = 12 and B = 36 \n");
printf("Bitwise Shift Right Operation (A >> 1) = %d\n",(A >> 1));
printf("Bitwise Shift Right Operation (B >> 2) = %d\n",(B >> 2));
return 0;
}
```

### Output

```
Consider A = 12 and B = 36
Bitwise Shift Right Operation (A >> 1) = 6
Bitwise Shift Right Operation (B >> 2) = 9
```

## 6. Bitwise Shift Left `<<`

Bitwise Shift Left is also similar to Bitwise Shift Right. It is used to shift the binary bits to Left by specific position.

**For Example:**

**Let a decimal number be 12.**

**And its binary is 00001100.**

Now if we shift bits of 12 left by 1 i.e. (12 « 1) then it would results 24.

**Let’s take another example**

**Consider a decimal number be 2.**

**And its binary is 00000010.**

Now if we shift bits of 2 left by 3 i.e (2 « 3) then it would results 16.

This concludes that if `m`

is the number and `n`

is the bits to shift left the it follows the rule `m*2^n`

.

### Program example of Bitwise Shift Left Operator

```
//An example of Bitwise Shift Left Operator
#include<stdio.h>
int main()
{
int A = 12, B = 2;
printf("Consider A = 12 and B = 2 \n");
printf("Bitwise Shift Left Operation (A << 1) = %d\n",(A << 1));
printf("Bitwise Shift Left Operation (B << 2) = %d\n",(B << 3));
return 0;
}
```

### Output

```
Consider A = 12 and B = 2
Bitwise Shift Left Operation (A << 1) = 24
Bitwise Shift Left Operation (B << 2) = 16
```