In C, the following 6 operators are bitwise operators (work at bitlevel)
 The & (bitwise AND) in C or C++ takes two numbers as operands and does AND on every bit of two numbers. The result of AND is 1 only if both bits are 1.
 The  (bitwise OR) in C or C++ takes two numbers as operands and does OR on every bit of two numbers. The result of OR is 1 if any of the two bits is 1.
 The ^ (bitwise XOR) in C or C++ takes two numbers as operands and does XOR on every bit of two numbers. The result of XOR is 1 if the two bits are different.
 The << (left shift) in C or C++ takes two numbers, left shifts the bits of the first operand, the second operand decides the number of places to shift.
 The >> (right shift) in C or C++ takes two numbers, right shifts the bits of the first operand, the second operand decides the number of places to shift.
 The ~ (bitwise NOT) in C or C++ takes one number and inverts all bits of it
Example:
// C Program to demonstrate use of bitwise operators #include <stdio.h> int main()
{ // a = 5(00000101), b = 9(00001001)
unsigned char a = 5, b = 9;
// The result is 00000001
printf ( "a = %d, b = %d\n" , a, b);
printf ( "a&b = %d\n" , a & b);
// The result is 00001101
printf ( "ab = %d\n" , a  b);
// The result is 00001100
printf ( "a^b = %d\n" , a ^ b);
// The result is 11111010
printf ( "~a = %d\n" , a = ~a);
// The result is 00010010
printf ( "b<<1 = %d\n" , b << 1);
// The result is 00000100
printf ( "b>>1 = %d\n" , b >> 1);
return 0;
} 
chevron_right
filter_none
Output:
a = 5, b = 9 a&b = 1 ab = 13 a^b = 12 ~a = 250 b>1 = 4
Interesting facts about bitwise operators
 The left shift and right shift operators should not be used for negative numbers. If any of the operands is a negative number, it results in undefined behaviour. For example results of both 1 << 1 and 1 << 1 is undefined. Also, if the number is shifted more than the size of integer, the behaviour is undefined. For example, 1 << 33 is undefined if integers are stored using 32 bits. See this for more details.

The bitwise XOR operator is the most useful operator from technical interview perspective. It is used in many problems. A simple example could be “Given a set of numbers where all elements occur even number of times except one number, find the odd occurring number” This problem can be efficiently solved by just doing XOR of all numbers.
#include <stdio.h>
// Function to return the only odd
// occurring element
int
findOdd(
int
arr[],
int
n)
{
int
res = 0, i;
for
(i = 0; i < n; i++)
res ^= arr[i];
return
res;
}
// Driver Method
int
main(
void
)
{
int
arr[] = { 12, 12, 14, 90, 14, 14, 14 };
int
n =
sizeof
(arr) /
sizeof
(arr[0]);
printf
(
"The odd occurring element is %d "
,
findOdd(arr, n));
return
0;
}
chevron_rightfilter_noneOutput:The odd occurring element is 90
The following are many other interesting problems using XOR operator.
 Find the Missing Number
 swap two numbers without using a temporary variable
 A Memory Efficient Doubly Linked List
 Find the two nonrepeating elements.
 Find the two numbers with odd occurences in an unsortedarray.
 Add two numbers without using arithmetic operators.
 Swap bits in a given number/.
 Count number of bits to be flipped to convert a to b .
 Find the element that appears once.
 Detect if two integers have opposite signs.
.

The bitwise operators should not be used in place of logical operators. The result of logical operators (&&,  and !) is either 0 or 1, but bitwise operators return an integer value. Also, the logical operators consider any nonzero operand as 1. For example, consider the following program, the results of & and && are different for same operands.
#include <stdio.h>
int
main()
{
int
x = 2, y = 5;
(x & y) ?
printf
(
"True "
) :
printf
(
"False "
);
(x && y) ?
printf
(
"True "
) :
printf
(
"False "
);
return
0;
}
chevron_rightfilter_noneOutput:False True

The leftshift and rightshift operators are equivalent to multiplication and division by 2 respectively. As mentioned in point 1, it works only if numbers are positive.
#include <stdio.h>
int
main()
{
int
x = 19;
printf
(
"x << 1 = %d\n"
, x << 1);
printf
(
"x >> 1 = %d\n"
, x >> 1);
return
0;
}
chevron_rightfilter_noneOutput:x > 1 = 9

The & operator can be used to quickly check if a number is odd or even. The value of expression (x & 1) would be nonzero only if x is odd, otherwise the value would be zero.
#include <stdio.h>
int
main()
{
int
x = 19;
(x & 1) ?
printf
(
"Odd"
) :
printf
(
"Even"
);
return
0;
}
chevron_rightfilter_noneOutput:Odd

The ~ operator should be used carefully. The result of ~ operator on a small number can be a big number if the result is stored in an unsigned variable. And the result may be a negative number if the result is stored in a signed variable (assuming that the negative numbers are stored in 2’s complement form where the leftmost bit is the sign bit)
// Note that the output of the following
// program is compiler dependent
#include <stdio.h>
int
main()
{
unsigned
int
x = 1;
printf
(
"Signed Result %d \n"
, ~x);
printf
(
"Unsigned Result %ud \n"
, ~x);
return
0;
}
chevron_rightfilter_noneOutput:Signed Result 2 Unsigned Result 4294967294d
 Bits manipulation (Important tactics)
 Bitwise Hacks for Competitive Programming
 Bit Tricks for Competitive Programming
 Total pairs in an array such that the bitwise AND, bitwise OR and bitwise XOR of LSB is 1
 Calculate Bitwise OR of two integers from their given Bitwise AND and Bitwise XOR values
 Operators in C  Set 2 (Relational and Logical Operators)
 Operators in C  Set 1 (Arithmetic Operators)
 Bitwise right shift operators in Java
 Russian Peasant (Multiply two numbers using bitwise operators)
 Check if a number is multiple of 9 using bitwise operators
 Case conversion (Lower to Upper and Vice Versa) of a string using BitWise operators in C/C++
 Toggle case of a string using Bitwise Operators
 Check if a number is divisible by 17 using bitwise operators
 Check if a number is divisible by 8 using bitwise operators
 Check if a Number is Odd or Even using Bitwise Operators
 Generate first K multiples of N using Bitwise operators
 What are the differences between bitwise and logical AND operators in C/C++?
 Compute maximum of two integers in C/C++ using Bitwise Operators
 Leftover element after performing alternate Bitwise OR and Bitwise XOR operations on adjacent pairs
 Find subsequences with maximum Bitwise AND and Bitwise OR
 Minimum possible Bitwise OR of all Bitwise AND of pairs generated from two given arrays
 Count ways to generate pairs having Bitwise XOR and Bitwise AND equal to X and Y respectively
 Count pairs with bitwise XOR exceeding bitwise AND from a given array
Important Links:
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a studentfriendly price and become industry ready.