# c bitwise operators snippet in c

## bit manipulation c++

user704

``````a = 5, b = 9
a&b = 1
a|b = 13
a^b = 12
~a = 250
b<<1 = 18
b>>1 = 4
``````

## shift operator c

user1965

``````/* C++ Program to demonstrate use of left shift
operator */
#include<stdio.h>
int main()
{
// a = 5(00000101), b = 9(00001001)
unsigned char a = 5, b = 9;

// The result is 00001010
printf("a<<1 = %d\n", a<<1);

// The result is 00010010
printf("b<<1 = %d\n", b<<1);
return 0;
}
``````

## bitwise operators explanation in c++

user1776

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

## shift operator in c

user5593

``````a<<1 = 10
b<<1 = 18

``````

## bitwise operator

user1880

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

## c bitwise operators

user8976

``````// An simple example for binary digits (bits):
// Example: 01001011
//        0  0  0  0 1 0 1 1
//      128 64 32 16 8 4 2 1
//      00001011 = 64 + 8 + 2 + 1 = 75

int i = 1;

if (i == true && i = 1 || i = 2)
{
//And operator -> &&
//Or operator -> ||
i = i << 1;
i = i >> 1;

//Shift bits to left operator -> <<

//Value of i :
//    0  0  0  0 0 0 0 1 } Value of i = 1
//  128 64 32 16 8 4 2 1 } Values

//    0   0  0  0  0 0 0 1 } Value of i = 2
//  256 128 64 32 16 8 4 2 } Values shifted this way : >>

// i << (number of times) is same as i * (number of times)

//Shift bits to right operator -> >>

//Value of i :
//    0   0  0  0  0 0 0 1 } Value of i = 1
//  256 128 64 32 16 8 4 2 } Values

//    0  0  0  0 0 0 0 1 } Value of i = 2
//  128 64 32 16 8 4 2 1 } Values shifted this way : <<

// i << (number of times) is same as i / (number of times)
}``````