C++ Bitset::operator>> Function

The C++ std::bitset::operator>> performs bitwise right SHIFT operation on the current bitset object. It stores the result in another (new) bitset object.

The bitwise right SHIFT operator shifts the bits of the operand to the right by the specified number of positions. The rightmost bits of the bitset object are discarded and a 0 bit is appended to the start of the resultant binary value. The number of times we need to append a 0 bit depends on the number of positions that the bits are shifted.

A bitwise operator operates on individual bits of a binary number, rather than the whole number. It can be used to perform different operations, such as setting and clearing specific bits, checking if a bit is set or not, and manipulating data packed into bit fields.

Syntax

Following is the syntax for std::bitset::operator>> −

bitset operator>>(size_t pos) const;

Parameters

pos − Number of bits to be shifted.

Return value

Returns new bitset object which contains shifted bits.

Example 1

The following example shows the usage of std::bitset::operator>> function on a single bitset operand.

Here, we are creating a bitset "b" of size "4" with the binary value "1000". Then, we are shifting the bits of "b" one position to the right using the bitwise right shift operator and storing the result in a new variable "result".

#include <iostream>
#include <bitset>
using namespace std;

int main(void) {
   bitset<4> b("1000");
   auto result = b >> 1;
   cout << result << endl;
   return 0;
}

Output

Let us compile and run the above program, this will produce the following result −

0100

Example 2

Here, we are reducing an integer value to its half using the operator>>.

In the following example, we are creating an integer variable "x" with an initial value of "10". Then, we are using the bitwise right shift operator to shift its bits to the right by one position, effectively dividing the value of "x" by "2". We are then storing the result in a new variable "res".

#include <iostream>
#include <bitset>
using namespace std;

int main(void) {
   int x = 10;
   int res = x >> 1;
   cout << res << endl;
   return 0;
}

Output

If we run the above code it will generate the following output −

5

Example 3

Now, we are setting a bit in a binary representation using the operator >>.

In the example given below, we are creating a 32-bit unsigned integer (non-negative values) variable called "mask" and assigning it with the hexadecimal value "0x08" (binary 1000). Then, we are using the bitwise right shift operator to move the binary digits of the original value to the right by "3" positions, effectively dividing it by 2³. We are then storing the result in a new variable "value".

#include <iostream>
#include <bitset>
using namespace std;

int main(void) {
   uint32_t mask = 0x08;
   auto value = mask >> 3;
   cout << value << endl;
   return 0;
}

Output

Following is an output of the above code −

1

Example 4

In here, we are shifting multiple values in an array to the right.

In the example below, we are creating an integer array "arr" with values "{16, 32, 64, 128}" (each value is formed by raising 2ⁿ). We are then creating an empty array "res" of size "4" to store the result in it. Then, we are shifting each element of the "arr" to the right by "4" bits using the bitwise right shift operator.

#include <iostream>
#include <bitset>
using namespace std;

int main(void) {
   int arr[] = {16, 32, 64, 128};
   int res[4];
   for (int i = 0; i < 4; i++) {
      // Shift right by 4 bits
      res[i] = arr[i] >> 4;          
      cout << res[i] << " ";  
   } 
   return 0;
}

Output

We can see that each value in the array is divided by 2 raised to the power of 4 (i.e. 16), effectively decreasing the value by a factor of 16 in the following output −

1 2 4 8