cpp / latest / utility / bitset.html /

std::bitset

Defined in header <bitset> 
template< std::size_t N >
class bitset;

The class template bitset represents a fixed-size sequence of N bits. Bitsets can be manipulated by standard logic operators and converted to and from strings and integers.

bitset meets the requirements of CopyConstructible and CopyAssignable.

Template parameters

N - the number of bits to allocate storage for

Member types

proxy class representing a reference to a bit
(class)

Member functions

constructs the bitset
(public member function)
(removed in C++20)
compares the contents
(public member function)
Element access
accesses specific bit
(public member function)
accesses specific bit
(public member function)
(C++11)
checks if all, any or none of the bits are set to true
(public member function)
returns the number of bits set to true
(public member function)
Capacity
returns the number of bits that the bitset holds
(public member function)
Modifiers
performs binary AND, OR, XOR and NOT
(public member function)
performs binary shift left and shift right
(public member function)
sets bits to true or given value
(public member function)
sets bits to false
(public member function)
toggles the values of bits
(public member function)
Conversions
returns a string representation of the data
(public member function)
returns an unsigned long integer representation of the data
(public member function)
(C++11)
returns an unsigned long long integer representation of the data
(public member function)

Non-member functions

performs binary logic operations on bitsets
(function template)
performs stream input and output of bitsets
(function template)

Helper classes

(C++11)
hash support for std::bitset
(class template specialization)

Notes

If the size of the bitset is not known at compile time, std::vector<bool> or boost::dynamic_bitset<> may be used.

Example

#include <bitset>
#include <cassert>
#include <iostream>
 
int main()
{
    // constructors:
    constexpr std::bitset<4> b1;
    constexpr std::bitset<4> b2{0xA}; // == 0B1010
    std::bitset<4> b3{"0011"}; // can't be constexpr yet
    std::bitset<8> b4{"ABBA", /*length*/4, /*0:*/'A', /*1:*/'B'}; // == 0B0000'0110
 
    // bitsets can be printed out to a stream:
    std::cout << "b1:" << b1 << "; b2:" << b2 << "; b3:" << b3 << "; b4:" << b4 << '\n';
 
    // bitset supports bitwise operations:
    b3 |= 0b0100; assert(b3 == 0b0111);
    b3 &= 0b0011; assert(b3 == 0b0011);
    b3 ^= std::bitset<4>{0b1100}; assert(b3 == 0b1111);
 
    // operations on the whole set:
    b3.reset(); assert(b3 == 0);
    b3.set(); assert(b3 == 0b1111);
    assert(b3.all() && b3.any() && !b3.none());
    b3.flip(); assert(b3 == 0);
 
    // operations on individual bits:
    b3.set(/* position = */ 1, true); assert(b3 == 0b0010);
    b3.set(/* position = */ 1, false); assert(b3 == 0);
    b3.flip(/* position = */ 2); assert(b3 == 0b0100);
    b3.reset(/* position = */ 2); assert(b3 == 0);
 
    // subscript operator[] is supported:
    b3[2] = true; assert(true == b3[2]);
 
    // other operations:
    assert(b3.count() == 1);
    assert(b3.size() == 4);
    assert(b3.to_ullong() == 0b0100ULL);
    assert(b3.to_string() == "0100");
}

Output:

b1:0000; b2:1010; b3:0011; b4:00000110

See also

space-efficient dynamic bitset
(class template specialization)
Bit manipulation (C++20) utilities to access, manipulate, and process individual bits and bit sequences

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/utility/bitset

Name C++
Version
Badge
Last Updated 2022-06-02T22:02:33Z