C Bitwise Operators

In 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.

C Bitwise Operators allows manipulation of data at bit level. It should also be noted that these operators cannot be applied on floating point numbers.

OperatorsMeaning of operators
&Bitwise AND
|Bitwise OR
^Bitwise XOR
~Bitwise complement
<<Shift left
>>Shift right

Bitwise AND Operator (&)

When two values are operated by bitwise & operator, the binary representation of both values are compared bit by bit. If each corresponding bit in the first value is 1 and also 1 in the second value, then it produces a 1 in corresponding bit position of result, anything else produces a 0.

Bit ABit BOutput Bit
000
010
100
111

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 Inclusive OR Operator (|)

When two values are operated by bitwise inclusive or operator, then the binary representation of two values are compared bit by bit. If a particular bit is 1 in either of the two values, then it produces 1 in corresponding bit of result, otherwise 0 is produced.

Bit ABit BOutput Bit
000
011
101
111

Let us suppose the bitwise OR operation of two integers 12 and 25.

```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 Exclusive OR Operator (^)

This operator often called the XOR operator works as follows. For corresponding bits of the two operands, if either bit is a 1, but not both, the corresponding bit of the result is 1, otherwise it is a 0.

It should be noted that if any value is exclusive ORed with itself, it produces 0.

Bit ABit BOutput Bit
000
011
101
110

Let us suppose the bitwise XOR operation of two integers 12 and 25.

```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 ~

Ones Complement Operator (~)

Ones complement operator is a unary operator which simply reverse the bits of its operand. Each bit of the operand if is a 1 is changed to 0, but if the bit is 0, then it is changed to 1.

Bit AOutput Bit
01
10

```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 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 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.

Left Shift Operator (<<)

Left shift operator shifts the bits of a value to the left. Bits that are shifted out through most significant bit of the data item are lost and 0s are always shifted in through least significant bit of the value.

Left shifting actually has the effect of multiplying the value that is shifted by two.

Left shifting n bits means the number x is multiplied by 2n.

y=x*2n

Above, x is the number and n is the number of bits to be shifted.

```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)```

Right Shift Operator (>>)

Right shift operator shifts the bits of a value to the right. Bits shifted out of least significant bit of value are lost. Right shifting an unsigned value always results in 0s being shifted on left.

If sign bit is 0 meaning value is positive, 0s are shifted in regardless of machine we are running.

However, if sign bit is 1, on the same machine 1s are shifted in known as arithmetic right shift and on others 0s are shifted in known as logical right shift.

Right shifting n bits means the number x is divided by 2n

y=x/2n

```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)```

MIND IT !

It should be noted that if an attempt is made to shift a value to the left or right by an amount which is either greater than or equal to number of bits in the data item, then the result produced is not defined in c.

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```