C++ Bitset and its Application

In C++, the bitset is a container that represents a fixed-size sequence of bits. A bitset allows you to manipulate individual bits efficiently, making it useful in problems related to bitwise operations, such as checking flags, implementing binary representations.

Bitset is defined as the std::bitset class template inside the <bitset> header file.

Creating a Bitset

The syntax to create bitset is as follows:

bitset<n> name;

where, n is the number of bits to allocate, and name is the name assigned.

Initializing

By default, when a bitset of a given size is created, all of its bits are unset i.e. 0. We can initialize it to some value simply by passing it to its constructor.

#include <bits/stdc++.h>
using namespace std;

int main() {
    
    // Default Initialization
    bitset<5> bnum(18);
    cout << bnum;
    return 0;
}

Here, the bitset bnum is of size 5 bits and stores the decimal value 18 in binary form.

Binary numbers are also represented as strings, so bitset also provide facility to initialize itself from the strings.

#include <bits/stdc++.h>
using namespace std;

int main() {
    
    // Initialize bitset with value
    bitset<5> bs2("10010");

    cout << bs2 << endl;
    return 0;
}

The string should represent a valid binary number i.e. all characters should be 0 or 1. Otherwise, an error may occur.

Accessing Individual Bits

We access the bit at any position by using below methods:

• test(pos): Returns 1 if the bit at position is 1, and 0 if it is 0.
• operator[pos]: Allows direct access to a bit at a given position.

Here, pos is the position or index of the bit starting from 0. It must be in the range (0 ≤ pos ≤ size – 1), otherwise, out of bound exception is thrown.

Example:

#include <bits/stdc++.h>
using namespace std;

int main() {
    
    // 18 = (10010)
    bitset<5> bs(18);
    
    // Check 3rd bit
    cout << bs[2] << endl;
    
    // Check 5th bit
    cout << bs.test(4);
    return 0;
}

0
1

Setting, Resetting and Flipping

Setting means making the bit at particular position 1 and resetting means making it 0. These operations can be done using set() and reset() function. The flip() function can be used to set the bit if it's not set and unset if it is set.

Example:

#include <bits/stdc++.h>
using namespace std;

int main() {
    bitset<5> bs(18);
    
    // Set 1st bit
    bs.set(0);
    cout << bs << endl;
    
    // Reset 2nd bit 
    bs.reset(1);
    cout << bs << endl;
    
    // Flip 5th bit
    bs.flip(4);
    cout << bs;
    return 0;
}

10011
10001
00001

Bitset Operators

Bitset objects can work with all the bitwise operators to provide seamless replacement integration in the code.

Example:

#include <bits/stdc++.h>
using namespace std;

int main() {

    // 18 = (10010)
    bitset<5> bs1(18);
    
    // 5 = (00101)
    bitset<5> bs2(5);
    
    // AND Operator 
    cout << (bs1 & bs2) << endl;
    
    // OR Operator
    cout << (bs1 | bs2) << endl;
    
    // XOR operator
    cout << (bs1 ^ bs2);
    return 0;
}

00000
10111
10111

Explanation: In the above example, we perform AND, OR and XOR operator on bitsets:

• bs1 & bs2: Return (0 0 0 0).
• bs1 | bs2: Print (1 0 1 1 1).
• bs1 ^ bs2: Print (1 0 1 1 1).

Other Basic Operations

• Find the Size of the Bitset
• Convert Bitset to Unsigned Long Long
• Convert Bitset to Unsigned Long
• Check if at least One Bit is Set in Bitset
• Check if all Bits are Unset
• Check if all Bits are Set

Internal Working

In C++, bitset is implemented using an array or similar structure to store its bits. When you perform operations like set(), reset(), or flip(), they directly modify the bits in the internal array. The size of the bitset is fixed at compile-time, and it cannot be dynamically resized.

Why Bitset is Preferred

Bitsets are a preferred choice for bitwise operations and binary data handling due to the following reasons:

• Bitsets are memory-efficient, as each bit occupies just one bit, making them ideal for large binary datasets.
• Bitsets enable efficient bit manipulation, providing a better alternative to integers or arrays of booleans for handling large bit sequences.
• The bitset provides an easy way to work with bits, eliminating the need for writing complicated custom functions.
• Since the size of a bitset is determined at compile time, it helps with consistent memory usage and performance, making it well-suited for applications where efficiency is important.
• Using bitsets clearly signals bit-level manipulation, which improves code clarity and reduces errors.

Difference between std::bitset and std::vector<bool> and an array of bool

Vector of bool and array of bool can also be implemented to store a sequence of boolean values like bitset but there are some differences between each implementation: 

All Member Functions

Here’s the list of all member functions of std::bitset: