boost::dynamic_bitset

The dynamic_bitset template represents a set of bits.

Synopsis

Declared in <boost/dynamic_bitset/dynamic_bitset.hpp>

template<
    typename Block = unsigned long,
    typename AllocatorOrContainer = std::allocator<Block>>
class dynamic_bitset;

Template parameters

Block The integer type in which the bits are stored. Defaults to unsigned long.
AllocatorOrContainer Either an allocator (to use for all internal memory management) or a container of Block's. Defaults to std::allocator< Block >.

Concepts modeled

DefaultConstructible, CopyConstructible, CopyAssignable, MoveConstructible, MoveAssignable, EqualityComparable, LessThanComparable.

Type requirements

Block is a cv‐unqualified unsigned integer type other than bool.

AllocatorOrContainer is taken as a container if it has a nested value_type which is Block, a member resize() taking a size, and an operator[] taking an index; otherwise, it is taken as an allocator. A type which is neither (for instance, std::list< Block >, which has no operator[]) is rejected by a static_assert.

If AllocatorOrContainer is an allocator, it satisfies the standard requirements for an allocator of Block, and the bits are stored in a std::vector< Block, AllocatorOrContainer >.

If AllocatorOrContainer is a container (for instance, a boost::container::small_vector< Block, N > or a std::deque< Block >), the bits are stored in an object of that type, which must provide, with the same semantics as for std::vector: the nested types allocator_type, iterator and const_iterator, the latter two being at least LegacyBidirectionalIterators; default, copy and move construction, construction from an allocator_type, and copy and move assignment; the members begin(), end(), cbegin(), cend(), size(), max_size(), empty(), get_allocator(), operator[], back(), resize( n ), resize( n, value ), push_back(), pop_back(), insert( pos, first, last ) and clear(); operator==; and swapping by an unqualified call to swap(), with std::swap() visible. In addition, capacity(), reserve(), shrink_to_fit() and the allocator‐extended copy and move constructors use further members of the container (capacity(), reserve(), a member swap(), and allocator‐extended copy and move constructors), as documented for each of them, and can't be used with a container which lacks them (for instance, std::deque has no capacity(), so the first three can't be used with it). Many members access the blocks through operator[], so they are efficient only if it takes constant time.

None of the following may throw an exception: the members begin(), end(), cbegin(), cend(), size(), max_size(), capacity(), get_allocator(), back() and clear() of the container, its operator==, its operator[] with a valid index, and the operations of its iterators on valid iterators. (The noexcept members of dynamic_bitset rely on that.)

Types

Name

Description

reference

A proxy class to simulate lvalues of bit type.

serialize_impl

Optional zero‐copy serialization support.

Type Aliases

Name

Description

allocator_type

The allocator used for all memory allocations: AllocatorOrContainer if it is an allocator, otherwise AllocatorOrContainer::allocator_type.

block_type

The same type as Block.

const_iterator

A read‐only iterator into the bitset.

const_reference

The type bool.

const_reverse_iterator

A reverse read‐only iterator into the bitset.

difference_type

A signed integral type that can represent the difference between any two iterators into the same bitset. The same type as iterator::difference_type and const_iterator::difference_type. See max_size().

iterator

A read/write iterator into the bitset.

reverse_iterator

A reverse read/write reverse iterator into the bitset.

size_type

An unsigned integral type that can represent the size of the bitset. See size().

value_type

The type bool, i.e. the type of the value of a bit.

Member Functions

Name

Description

dynamic_bitset [constructor]

Constructors

~dynamic_bitset [destructor]

Destructor.

operator=

Assignment operators

all

Checks whether all bits in *this are set.

any

Checks whether any bits in *this are set.

append

append overloads

at

A checked version of operator.

begin

begin overloads

capacity

Returns the total number of elements that *this can hold without requiring reallocation.

cbegin

Returns a read‐only iterator that refers to the least significant bit in the bitset.

cend

Returns a read‐only iterator that refers to one past the most significant bit in the bitset.

clear

Clears the bitset, i.e. makes its size zero.

count

Returns the number of bits in this bitset that are set.

crbegin

Returns a read‐only reverse iterator that refers to the most significant bit in the bitset.

crend

Returns a read‐only reverse iterator that refers to one before the least significant bit in the bitset.

empty

Checks whether this bitset has size zero.

end

end overloads

extract

Returns the bitset made of the bits of *this in a given range.

find_first

Finds the first set bit in *this with an index >= pos, if any.

find_first_off

Finds the first unset bit in *this with an index >= pos, if any.

find_next

Finds the first bit set in *this with an index > pos, if any.

find_next_off

Finds the first unset bit in *this with an index > pos, if any.

flip

flip overloads

get_allocator

Returns a copy of the allocator that this bitset currently uses.

intersects

Checks whether *this intersects with b.

is_proper_subset_of

Checks whether *this is a proper subset of b.

is_subset_of

Checks whether *this is a subset of b.

max_size

Returns the maximum size of a bitset of this type.

none

Checks whether this bitset has no set bit.

num_blocks

Returns the number of blocks in this bitset.

operator&=

Bitwise‐ANDs all the bits in this bitset with the bits in b.

operator‐=

Computes the set difference of this bitset and the b bitset.

operator<<=

Shifts the bits in this bitset to the left by n positions.

operator>>

Returns a shifted copy of *this.

operator>>=

Shifts the bits in this bitset to the right by n positions.

operator[]

Subscript operators

operatorˆ=

Bitwise‐XORs all the bits in this bitset with the bits in b.

operator|=

Bitwise‐ORs all the bits in this bitset with the bits in b.

operator~

Returns a copy of *this with all of its bits toggled.

pop_back

Decreases the size of the bitset by one, removing the most significant bit.

pop_front

Decreases the size of the bitset by one, removing the least significant bit.

push_back

Increases the size of the bitset by one, and sets the value of the new most significant bit to bit.

push_front

Increases the size of the bitset by one, and sets the value of the new least significant bit to bit.

rbegin

rbegin overloads

rend

rend overloads

reserve

Informs the bitset of a planned change in size, so that it can manage the storage allocation accordingly.

reset

reset overloads

resize

Changes the number of bits of the bitset to num_bits.

set

set overloads

shrink_to_fit

Requests the bitset to reduce memory use by removing unused capacity.

size

Returns the number of bits in this bitset.

swap

Swaps the contents of this bitset and bitset b.

test

Tests the bit at the given position.

test_set

Sets bit pos if val is true, and clears it if val is false.

to_number

Returns the numeric value corresponding to the bits in *this (zero if *this is empty).

to_string

Returns a representation of *this as a string of zero and one characters, highest bit first.

to_ulong

Returns the numeric value corresponding to the bits in *this (zero if *this is empty).

operator<<

Returns a shifted copy of *this.

Static Data Members

Name

Description

bits_per_block

The number of bits the type Block uses to represent values, excluding any padding bits. Numerically equal to std::numeric_limits< Block >::digits.

npos

The maximum value of size_type.