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.
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;
}
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;
}
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;
}
Output

Output = 21

Bitwise complement operator ~

Bitwise compliment operator is an 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) = -00000000 = -
0(decimal)
1 00000001 -(11111110+1) = -11111111 = -
256(decimal)
12 00001100 -(11110011+1) = -11110100 = -
244(decimal)
220 11011100 -(00100011+1) = -00100100 = -
36(decimal)

Note: Overflow is ignored while computing 2's complement.

The bitwise complement of 35 is 220 (in decimal). The 2's complement of

200 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 complement form)
2'complement of ~N= -(~(~N)+1) = -(N+1)

Example #4: Bitwise complement

#include <stdio.h>
int main()
{
printf("complement = %d\n",~35);
printf("complement = %d\n",~-12);
return 0;
}
Output

complement = -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 certain number of specified
bits. It is denoted by <<.

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;
}

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
 Bitwise Operators in C
The following table lists the Bitwise operators supported by C. Assume
variable 'A' holds 60 and variable 'B' holds 13, then −

Operator Description Example

& Binary AND Operator copies a bit to the result if it exists (A & B) =
in both operands. 12 i.e.,
0000 1100

∣ Binary OR Operator copies a bit if it exists in either (A ∣ B) = 61

operand. i.e., 0011
1101

^ Binary XOR Operator copies the bit if it is set in one (A ^ B) =

operand but not both. 49 i.e.,
0011 0001

~ Binary Ones Complement Operator is unary and has the (~A ) = 61

effect of 'flipping' bits. i.e., 1100
0011 in 2's
complement
form.

<< Binary Left Shift Operator. The left operands value is A << 2 =
moved left by the number of bits specified by the right 240 i.e.,
operand. 1111 0000

>> Binary Right Shift Operator. The left operands value is A >> 2 =
moved right by the number of bits specified by the right 15 i.e.,
operand. 0000 1111

Example
Try the following example to understand all the bitwise operators
available in C −

#include <stdio.h>

main() {

unsigned int a = 60; /* 60 = 0011 1100 */

unsigned int b = 13; /* 13 = 0000 1101 */
 int c = 0;

c = a & b; /* 12 = 0000 1100 */

printf("Line 1 - Value of c is %d\n", c );

c = a | b; /* 61 = 0011 1101 */
printf("Line 2 - Value of c is %d\n", c );

c = a ^ b; /* 49 = 0011 0001 */
printf("Line 3 - Value of c is %d\n", c );

c = ~a; /*-61 = 1100 0011 */

printf("Line 4 - Value of c is %d\n", c );

c = a << 2; /* 240 = 1111 0000 */

printf("Line 5 - Value of c is %d\n", c );

c = a >> 2; /* 15 = 0000 1111 */

printf("Line 6 - Value of c is %d\n", c );
}

When you compile and execute the above program, it produces the
following result −

Line 1 - Value of c is 12
Line 2 - Value of c is 61
Line 3 - Value of c is 49
Line 4 - Value of c is -61
Line 5 - Value of c is 240
Line 6 - Value of c is 15