C++ Library - <bit>

The <bit> header in C++, provides several functions for bit manipulation and bitwise operations, which are essential for low-level programming tasks. Includes functions for counting bits, finding the highest/lowest set bit etc. This header is part of the Numeric library.

Including <bit> Header

To include the <bit> header in your C++ program, you can use the following syntax.

#include <bit>

Functions of <bit> Header

Below is list of all functions from <bit> header.

Type Casting and Byte Manipulation

In C++ type casting and byte manipulation functions deals with representation of data types at the byte level. The binary representation of data is crucial for data serialization and performance optimization.

Manual Byteswap Implementation

In the following example, we are going to implement byteswap manually.

#include <bit>
#include <iostream>
uint16_t manual_byteswap(uint16_t value) {
    return (value >> 8) | (value << 8); 
}

int main() {
    uint16_t value = 0x1234; 
    uint16_t swapped = manual_byteswap(value); 
    std::cout << std::hex << swapped; 
    return 0;
}

Output

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

3412

Power of Two Operations

By using these opeartions, we can Check whether a number is a power of two, or finding the nearest power of two, can optimize memory allocation or bitwise operations.

Finding the smallest power

In the following example, we are going to find the smallest power of two using bit_ceil.

#include <bit>
#include <iostream>

int main() {
    uint32_t value = 10; 
    uint32_t ceil_value = std::bit_ceil(value); 
    std::cout  << ceil_value;
    return 0;
}

Output

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

16

Bitwise Rotation

Bitwise rotation involves shifting the bits of a number left or right.These Rotations are commonly used in cryptographic algorithms, hash functions, and low-level optimizations

Rotating bits

In the following example, we are going to use rotl to rotate the bits of a number to the left.

#include <bitset>
#include <bit>
#include <iostream>
uint8_t manual_rotl(uint8_t value, int shift) {
    return (value << shift) | (value >> (8 - shift));
}
int main() {
    uint8_t value = 0b10110001; 
    uint8_t rotated = manual_rotl(value, 2); 
    std::cout << std::bitset<8>(rotated); 
    return 0;
}

Output

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

11000110

Bit Counting

Bit counting functions are used to count consecutive bits (0s or 1s) or total bits set to 1. These operations are mostly used in low-level programming, where efficient manipulation of individual bits can significantly optimize performance.

Counting the Bits Manually

In the following example, we are going to use popcount to count the number of bits set to 1 in a number.

#include <bit>
#include <iostream>
uint32_t manual_popcount(uint32_t value) {
    uint32_t count = 0;
    while (value) {
        count += value & 1; 
        value >>= 1;       
    }
    return count;
}
int main() {
    uint32_t value = 0b10110001; 
    uint32_t count = manual_popcount(value);
    std::cout << "Number of 1s: " << count; 
    return 0;
}

Output

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

Number of 1s: 4