Bitwise Operators are used to perform bit-level operations 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