# Bit Manipulation in C++

The high-level language in which we communicate is not understood by the computer. As a result, there existed a standard mechanism for understanding any instruction sent to the computer. At the most basic level, each instruction was converted into bits of digital data. The sequence of bits denotes that this is a specific instruction.

## What is a Bit in C++?

A bit is the fundamental unit of data storage in digital notation.

Bit is represented by two values as follows:

1: It indicates whether or not the signal is present.

0: It means the signal is not present or is false.

Any instruction's logical state is represented by bits. The base of the series of bits is 2. As a result, when we have a series of binary digits, they are read from left to right, which increases the power of two. So, now that we’ve covered the basics of a little cheat in C ++, let’s take a look at how it’s done.

### Bit Manipulation

Bit manipulation is described as executing fundamental operations on bits at the n-digit level. It's a quick and simple procedure because it works directly on the machine. Let's get started with the fundamentals of bit manipulation in C++.

#### AND

The logical AND operator takes two operands and returns true if they are both true. && is the sign.

### Take a peek at the AND operator's truth table.

A and B are both high on the last row, resulting in a high output.

### Example of program showing the function of AND operator in C++:

``````#include <iostream>
using namespace std;
int main() {
int i = 2;
int j = 4;
// false && false = false
cout << ((i == 0) && (i > j)) << endl;
// false && true = false
cout << ((i == 0) && (i < j)) << endl;
// true && false = false
cout << ((i == 2) && (i > j)) << endl;
// true && true = true
cout << ((i == 2) && (i < j)) << endl;
return 0;
}
``````

OUTPUT:

``````0
0
0
1
``````

Explanation:

In the above program in C++, in the line number seven we have demonstrated the use of AND operator which is basically telling us what condition is true or not .i.e both the condition has to be true for the further execution.

### OR

If any of the two operands' inputs is high, logical OR produces a high output. || is the sign. Take a look at the OR operator's truth table.

The first row may be seen here. Because both A and B are low, the outcome is 0. (a low output).

### Example of program showing the function of OR operator in C++:

``````#include <iostream>
#include <bits/stdc++.h>
#include <stdlib>
using namespace std;
int main() {
int i = 2;
int j = 10;
// false && false = false
cout << ((i == 0) || (i > j)) << endl;
// false && true = true
cout << ((i == 0) || (i < j)) << endl;
// true && false = true
cout << ((i == 2) || (i > j)) << endl;
// true && true = true
cout << ((i == 2) || (i < j)) << endl;
return 0;
}
``````

OUTPUT:

``````0
1
1
1
``````

Explanation

In the above program in C++, in the line number nine we have demonstrated the use of OR operator which is basically telling us what condition is true or not .i.e if either of the condition is true both then program will further execute.

### NOT

Only one operand is reverted with logical NOT. It raises the operand if it is low, and vice versa. ! is the symbol. Take a look at the NOT operator's truth table.

### Example of program showing the function of NOT operator in C++:

``````#include <iostream>
#inlcude <bits/sdtc++.h>
#include <stdlib>
using namespace std;

int main() {
int i = 2;
// !false = true
cout << !(i == 0) << endl;
// !true = false
cout << !(i == 2) << endl;
return 0;
}
``````

OUTPUT:

``````1
0
``````

Explanation

In the above program in C++, in the line number nine we have demonstrated the use of NOT operator which is basically telling the opposite of  the condition we are passing .i.e if i is equal to 0 then adding NOT operator while think the opposite of it .i.e i is not equal to zero.

## Left Shift Operator

The value of the left operand is shifted left by the number of bits supplied by the right operand when using the left shift operator. It is indicated by the symbol <<.

### Example of program showing the function of left shift operator in C++:

``````#include<iostream>
#inlucde<bits/sdtc++.h>
#include<stdlib>
using namespace std;
int main()
{
// i = 2(0000100001), j = 5(0000000101)
unsigned char i = 2, j = 5;
// The result is 0001001010
cout << "i<<1: "<<  (i<<1) << "\n";
// The result is 0001001010
cout << "j<<1: " <<  (j<<1);
return 0;
}
``````

OUTPUT:

``````i<<10
j<<18
``````

Explanation:

In the above program, left shift operator operates in binary bits. It is a binary operator that requires two operands to change or change the location of the bits on the left side and add zero to the empty space by moving the bits.

## Right Shift Operator

The right shift operator accepts an operand and shifts its value to the right by the number of bits provided in the right operand. >> is the symbol for it.

### Example of program showing the function of right shift operator in C++:

``````#include <bits/stdc++.h>
#include <stdlib>
#include <>iostream>
using namespace std;
int main()
{
// i = 2(00010001), j = 5(00000101)
unsigned char i = 2, j = 5;
// The result is 000001000
cout<< "i>>1: " <<  (i >> 1) << "\n";
// The result is 00000100
cout<< "i>>1: " <<  (j >> 1);
return 0;
}
``````

OUTPUT:

``````i>>2
j>>4
``````

Explanation

In the above program, The right switch operator changes the bit pattern to the switch in the number of areas assigned to the right quotation.

### Let us see how to compute XOR from 1 to n:

``````#include<isotream>
#include<bits/stdc++.h>
#include<stdlib>
// Direct XOR of all numbers from 1 to n
int computeXOR(int n)
{
if (n % 4 == 0)
return n;
if (n % 4 == 1)
return 1;
if (n % 4 == 2)
return n + 1;
else
return 0;
}
``````

OUTPUT:

``````6
7
``````

NOTE:

In the above code input is 6.

Explanation

In the above program in C++, If all input bits are the same, output is false (0) otherwise, the output is true (1).