66% Learn to code solving problems with our hands-on C
off Programming course! Try Programiz PRO today.
Search tutorials & examples Programiz PRO
Bitwise Operators in C
Programming
In the arithmetic-logic unit (which is within the CPU),
mathematical operations like: addition, subtraction,
multiplication and division are done in bit-level. To
perform bit-level operations in C programming, bitwise
operators are used.
Operators Meaning of operators
& Bitwise AND
| Bitwise OR
^ Bitwise XOR
~ Bitwise complement
Shift left
>> Shift right
Bitwise AND Operator &
The output of bitwise AND is 1 if the corresponding bits of
two operands is 1. If either bit of an operand is 0, the result
of corresponding bit is evaluated to 0.
In C Programming, the bitwise AND operator is denoted
by & .
Let us suppose the bitwise AND operation of two integers
12 and 25.
12 = 00001100 (In Binary)
25 = 00011001 (In Binary)
Bit Operation of 12 and 25
00001100
& 00011001
________
00001000 = 8 (In decimal)
Example 1: Bitwise AND
#include <stdio.h>
int main() {
int a = 12, b = 25;
printf("Output = %d", a & b);
return 0;
}
Run Code
Output
Output = 8
Bitwise OR Operator |
The output of bitwise OR is 1 if at least one corresponding
bit of two operands is 1. In C Programming, bitwise OR
operator is denoted by | .
12 = 00001100 (In Binary)
25 = 00011001 (In Binary)
Bitwise OR Operation of 12 and 25
00001100
| 00011001
________
00011101 = 29 (In decimal)
Example 2: Bitwise OR
#include <stdio.h>
int main() {
int a = 12, b = 25;
printf("Output = %d", a | b);
return 0;
}
Run Code
Output
Output = 29
Bitwise XOR (exclusive OR) Operator
^
The result of bitwise XOR operator is 1 if the corresponding
bits of two operands are opposite. It is denoted by ^ .
12 = 00001100 (In Binary)
25 = 00011001 (In Binary)
Bitwise XOR Operation of 12 and 25
00001100
^ 00011001
________
00010101 = 21 (In decimal)
Example 3: Bitwise XOR
#include <stdio.h>
int main() {
int a = 12, b = 25;
printf("Output = %d", a ^ b);
return 0;
}
Run Code
Output
Output = 21
Bitwise Complement Operator ~
Bitwise complement operator is a unary operator (works
on only one operand). It changes 1 to 0 and 0 to 1. It is
denoted by ~ .
35 = 00100011 (In Binary)
Bitwise complement Operation of 35
~ 00100011
________
11011100 = 220 (In decimal)
Twist in Bitwise Complement Operator in
C Programming
The bitwise complement of 35 ( ~35 ) is -36 instead of 220,
but why?
For any integer n , bitwise complement of n will be
-(n + 1) . To understand this, you should have the
knowledge of 2's complement.
2's Complement
Two's complement is an operation on binary numbers. The
2's complement of a number is equal to the complement
of that number plus 1. For example:
Decimal Binary 2's complement
0 00000000 -(11111111+1) = -00000
1 00000001 -(11111110+1) = -11111
12 00001100 -(11110011+1) = -11110
220 11011100 -(00100011+1) = -00100
Note: Overflow is ignored while computing 2's complement.
The bitwise complement of 35 is 220 (in decimal). The 2's
complement of 220 is -36. Hence, the output is -36
instead of 220.
Bitwise Complement of Any Number N is -(N+1). Here's
how:
bitwise complement of N = ~N (represented in 2's compleme
2'complement of ~N= -(~(~N)+1) = -(N+1)
Example 4: Bitwise complement
#include <stdio.h>
int main() {
printf("Output = %d\n", ~35);
printf("Output = %d\n", ~-12);
return 0;
}
Run Code
Output
Output = -36
Output = 11
Shift Operators in C programming
There are two shift operators in C programming:
Right shift operator
Left shift operator.
Right Shift Operator
Right shift operator shifts all bits towards right by certain
number of specified bits. It is denoted by >> .
212 = 11010100 (In binary)
212 >> 2 = 00110101 (In binary) [Right shift by two bits]
212 >> 7 = 00000001 (In binary)
212 >> 8 = 00000000
212 >> 0 = 11010100 (No Shift)
Left Shift Operator
Left shift operator shifts all bits towards left by a certain
number of specified bits. The bit positions that have been
vacated by the left shift operator are filled with 0. The
symbol of the left shift operator is << .
212 = 11010100 (In binary)
212<<1 = 110101000 (In binary) [Left shift by one bit]
212<<0 = 11010100 (Shift by 0)
212<<4 = 110101000000 (In binary) =3392(In decimal)
Example #5: Shift Operators
#include <stdio.h>
int main() {
int num=212, i;
for (i = 0; i <= 2; ++i) {
printf("Right shift by %d: %d\n", i, num >> i);
}
printf("\n");
for (i = 0; i <= 2; ++i) {
printf("Left shift by %d: %d\n", i, num << i);
}
return 0;
}
Run Code
Right Shift by 0: 212
Right Shift by 1: 106
Right Shift by 2: 53
Left Shift by 0: 212
Left Shift by 1: 424
Left Shift by 2: 848
