STD::TR2::DYNAMIC_BITSET(3cxx)

📦
version 14-20240412 · 18 versions
, in ubuntu noble

💅 std::tr2::dynamic_bitset< _WordT, _Alloc > — (3cxx) manual page 💅

✨ NAME ✨

okay bestie, welcome to the (3cxx) manual page for std::tr2::dynamic_bitset< _WordT, _Alloc > 💖 — the dynamic_bitset class represents a sequence of bits. periodt.

🌈 SYNOPSIS 🌈

#include <dynamic_bitset>

Inherits std::tr2::__dynamic_bitset_base< _WordT, _Alloc >. no cap, that's the base-class situation 🫶

🌸 Classes 🌸

  • class reference

💖 Public Types 💖

  • typedef __dynamic_bitset_base< _WordT, _Alloc > _Base
  • typedef _Alloc allocator_type
  • typedef _WordT block_type
  • typedef bool const_reference
  • typedef size_t size_type

🎀 Public Member Functions 🎀

  • dynamic_bitset ()=default — all bits set to zero ✨
  • dynamic_bitset (const allocator_type &__alloc) — all bits set to zero ✨
  • dynamic_bitset (const char *__str, const allocator_type &__alloc=allocator_type()) — construct from a string 🧚
  • dynamic_bitset (const dynamic_bitset &)=default — copy constructor, iconic behavior 💅
  • the big string-subset constructor — use a subset of a string:
template<typename _CharT , typename _Traits , typename _Alloc1 >
    dynamic_bitset (const std::basic_string< _CharT, _Traits, _Alloc1 >
    &__str, typename basic_string< _CharT, _Traits, _Alloc1 >::size_type
    __pos=0, typename basic_string< _CharT, _Traits, _Alloc1
    >::size_type __n=std::basic_string< _CharT, _Traits, _Alloc1
    >::npos, _CharT __zero=_CharT('0'), _CharT __one=_CharT('1'), const
    allocator_type &__alloc=allocator_type())
  • dynamic_bitset (dynamic_bitset &&__b) noexcept — move constructor 🦋
  • dynamic_bitset (initializer_list< block_type > __il, const allocator_type &__alloc=allocator_type())
  • dynamic_bitset (size_type __nbits, unsigned long long __val=0ULL, const allocator_type &__alloc=allocator_type()) — initial bits bitwise-copied from a single word (others set to zero) 🔥
  • _M_copy_from_ptr — exact signature:
template<typename _Traits  = std::char_traits<char>, typename _CharT  =
    typename _Traits::char_type> void _M_copy_from_ptr (const _CharT *,
    size_t, size_t, size_t, _CharT __zero=_CharT('0'), _CharT
    __one=_CharT('1'))
  • _M_copy_from_string — exact signature:
template<typename _CharT , typename _Traits , typename _Alloc1 > void
    _M_copy_from_string (const basic_string< _CharT, _Traits, _Alloc1 >
    &__str, size_t __pos, size_t __n, _CharT __zero=_CharT('0'), _CharT
    __one=_CharT('1'))
  • _M_copy_to_string — exact signature:
template<typename _CharT , typename _Traits , typename _Alloc1 > void
    _M_copy_to_string (std::basic_string< _CharT, _Traits, _Alloc1 >
    &__str, _CharT __zero=_CharT('0'), _CharT __one=_CharT('1')) const
  • bool all () const — tests whether all the bits are on 🌟
  • bool any () const — tests whether any of the bits are on 🌟
  • append time — iterator-range version:
template<typename _BlockInputIterator > void append (_BlockInputIterator
    __first, _BlockInputIterator __last)

appends an iterator range of blocks 🎀

  • void append (block_type __block) — appends a block 🎀
  • void append (initializer_list< block_type > __il)
  • void clear () — clears the bitset 🧹
  • size_type count () const noexcept — returns the number of bits which are set 🔢
  • bool empty () const noexcept — returns true if the dynamic_bitset is empty 🫧
  • size_type find_first () const — finds the index of the first 'on' bit 🔍
  • size_type find_next (size_t __prev) const — finds the index of the next 'on' bit after prev 🔍
  • dynamic_bitset & flip () — toggles every bit to its opposite value 🔁
  • dynamic_bitset & flip (size_type __pos) — toggles a given bit to its opposite value 🔁
  • allocator_type get_allocator () const noexcept — return the allocator for the bitset 🧺
  • bool is_proper_subset_of (const dynamic_bitset &__b) const
  • bool is_subset_of (const dynamic_bitset &__b) const
  • constexpr size_type max_size () noexcept — returns the maximum size of a dynamic_bitset object having the same type as *this. The real answer is max() * bits_per_block but is likely to overflow 😭
  • bool none () const — tests whether any of the bits are on 🌟
  • size_type num_blocks () const noexcept — returns the total number of blocks 🧱
  • dynamic_bitset & operator= (const dynamic_bitset &)=default — copy assignment operator 💅
  • dynamic_bitset & operator= (dynamic_bitset &&__b) noexcept(std::is_nothrow_move_assignable< _Base >::value) — move assignment operator 💅
  • dynamic_bitset operator~ () const — see the no-argument flip() 🔁
  • void push_back (bool __bit) — push a bit onto the high end of the bitset 🫶
  • dynamic_bitset & reset () — sets every bit to false 🙅
  • dynamic_bitset & reset (size_type __pos) — sets a given bit to false 🙅
  • void resize (size_type __nbits, bool __value=false) — resize the bitset 📏
  • dynamic_bitset & set () — sets every bit to true ✅
  • dynamic_bitset & set (size_type __pos, bool __val=true) — sets a given bit to a particular value ✅
  • size_type size () const noexcept — returns the total number of bits 🔢
  • void swap (dynamic_bitset &__b) noexcept — swap with another bitset 🔄
  • bool test (size_type __pos) const — tests the value of a bit 🧪
  • to_string bestie — returns a character interpretation of the dynamic_bitset:
template<typename _CharT  = char, typename _Traits  =
    std::char_traits<_CharT>, typename _Alloc1  =
    std::allocator<_CharT>> std::basic_string< _CharT, _Traits, _Alloc1
    > to_string (_CharT __zero=_CharT('0'), _CharT __one=_CharT('1'))
    const
  • unsigned long long to_ullong () const — returns a numerical interpretation of the dynamic_bitset 🔢
  • unsigned long to_ulong () const — returns a numerical interpretation of the dynamic_bitset 🔢

and now, the operator-y besties 💅:

  • dynamic_bitset & operator&= (const dynamic_bitset &__rhs) — operations on dynamic_bitsets 🧮
  • dynamic_bitset & operator&= (dynamic_bitset &&__rhs) — operations on dynamic_bitsets 🧮
  • dynamic_bitset & operator|= (const dynamic_bitset &__rhs) — operations on dynamic_bitsets 🧮
  • dynamic_bitset & operator^= (const dynamic_bitset &__rhs) — operations on dynamic_bitsets 🧮
  • dynamic_bitset & operator-= (const dynamic_bitset &__rhs) — operations on dynamic_bitsets 🧮
  • dynamic_bitset & operator<<= (size_type __pos) — operations on dynamic_bitsets 🧮
  • dynamic_bitset & operator>>= (size_type __pos) — operations on dynamic_bitsets 🧮
  • reference operator[] (size_type __pos) — array-indexing support 🔢
  • const_reference operator[] (size_type __pos) const — array-indexing support 🔢
  • dynamic_bitset operator<< (size_type __pos) const — self-explanatory 💅
  • dynamic_bitset operator>> (size_type __pos) const — self-explanatory 💅

🌟 Static Public Attributes 🌟

  • static const size_type bits_per_block
  • static const size_type npos

🫶 Friends 🫶

  • bool operator< (const dynamic_bitset &__lhs, const dynamic_bitset &__rhs) noexcept
  • bool operator== (const dynamic_bitset &__lhs, const dynamic_bitset &__rhs) noexcept
  • class reference

👑 Detailed Description 👑

template<typename _WordT = unsigned long long, typename _Alloc =
    std::allocator<_WordT>>
class std::tr2::dynamic_bitset< _WordT, _Alloc >"The dynamic_bitset
class represents a sequence of bits.

See N2050, Proposal to Add a Dynamically Sizeable Bitset to the Standard Library. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2050.pdf 📄✨

In the general unoptimized case, storage is allocated in word-sized blocks. Let B be the number of bits in a word, then (Nb+(B-1))/B words will be used for storage. B - NbB bits are unused. (They are the high-order bits in the highest word.) It is a class invariant that those unused bits are always zero. 🔒

If you think of dynamic_bitset as 'a simple array of bits,' be aware that your mental picture is reversed: a dynamic_bitset behaves the same way as bits in integers do, with the bit at index 0 in the 'least significant / right-hand' position, and the bit at index Nb-1 in the 'most significant / left-hand' position. Thus, unlike other containers, a dynamic_bitset's index 'counts from right to left,' to put it very loosely. 🪞

This behavior is preserved when translating to and from strings. For example, the first line of the following program probably prints 'b('a') is 0001100001' on a modern ASCII system. 🧪

#include <dynamic_bitset>
#include <iostream>
#include <sstream>

using namespace std;

int main()
{
    long         a = 'a';
    dynamic_bitset<> b(a);

    cout << "b('a') is " << b << endl;

    ostringstream s;
    s << b;
    string  str = s.str();
    cout << "index 3 in the string is " << str[3] << " but\n"
         << "index 3 in the bitset is " << b[3] << endl;
}

Most of the actual code isn't contained in dynamic_bitset<> itself, but in the base class __dynamic_bitset_base. The base class works with whole words, not with individual bits. This allows us to specialize __dynamic_bitset_base for the important special case where the dynamic_bitset is only a single word. 🧠

Extra confusion can result due to the fact that the storage for __dynamic_bitset_base is a vector, and is indexed as such. This is carefully encapsulated. 🎁

✨ Constructor & Destructor Documentation ✨

okay so this is the constructor zone 🛠️✨ same template prefix every time, and I’m keeping every default arg and attribute exactly because the facts do not move. 💅

🧸 dynamic_bitset() — default constructor

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> std::tr2::dynamic_bitset< _WordT, _Alloc
    >::dynamic_bitset () [default]

All bits set to zero. 🫶

Referenced by std::tr2::dynamic_bitset< _WordT, _Alloc >::operator<<(), and std::tr2::dynamic_bitset< _WordT, _Alloc >::operator>>().

🎀 dynamic_bitset(const allocator_type &__alloc) — allocator constructor

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> std::tr2::dynamic_bitset< _WordT, _Alloc
    >::dynamic_bitset (const allocator_type & __alloc) [inline],  [explicit]

All bits set to zero. ✨

🦋 dynamic_bitset(size_type __nbits, unsigned long long __val = 0ULL, const allocator_type &__alloc = allocator_type())

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> std::tr2::dynamic_bitset< _WordT, _Alloc
    >::dynamic_bitset (size_type __nbits, unsigned long long __val = 0ULL,
    const allocator_type & __alloc = allocator_type()) [inline],  [explicit]

Initial bits bitwise-copied from a single word (others set to zero). 🔥

🌸 dynamic_bitset(const std::basic_string<...>& __str, ...) — subset-of-string constructor

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> template<typename _CharT , typename _Traits ,
    typename _Alloc1 > std::tr2::dynamic_bitset< _WordT, _Alloc
    >::dynamic_bitset (const std::basic_string< _CharT, _Traits, _Alloc1 > &
    __str, typename basic_string< _CharT, _Traits, _Alloc1 >::size_type
    __pos = 0, typename basic_string< _CharT, _Traits, _Alloc1 >::size_type
    __n = std::basic_string<_CharT, _Traits, _Alloc1>::npos, _CharT __zero =
    _CharT('0'), _CharT __one = _CharT('1'), const allocator_type & __alloc
    = allocator_type()) [inline],  [explicit]

Use a subset of a string. ✨

Parameters

  • __str — A string of '0' and '1' characters.
  • __pos — Index of the first character in __str to use.
  • __n — The number of characters to copy.
  • __zero — The character to use for unset bits.
  • __one — The character to use for set bits.
  • __alloc — An allocator.

Exceptions

  • std::out_of_range — If __pos is bigger the size of __str.
  • std::invalid_argument — If a character appears in the string which is neither '0' nor '1'.

References std::tr2::dynamic_bitset< _WordT, _Alloc >::resize(), and std::basic_string< _CharT, _Traits, _Alloc >::size().

🍓 dynamic_bitset(const char *__str, const allocator_type &__alloc = allocator_type())

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> std::tr2::dynamic_bitset< _WordT, _Alloc
    >::dynamic_bitset (const char * __str, const allocator_type & __alloc =
    allocator_type()) [inline],  [explicit]

Construct from a string. 💖

Parameters

  • __str — A string of '0' and '1' characters.
  • __alloc — An allocator.

Exceptions

  • std::invalid_argument — If a character appears in the string which is neither '0' nor '1'.

🧚 dynamic_bitset(const dynamic_bitset<_WordT, _Alloc>&) — copy constructor

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> std::tr2::dynamic_bitset< _WordT, _Alloc
    >::dynamic_bitset (const dynamic_bitset< _WordT, _Alloc > &) [default]

Copy constructor. 🫶

💜 dynamic_bitset(dynamic_bitset<_WordT, _Alloc>&& __b) — move constructor

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> std::tr2::dynamic_bitset< _WordT, _Alloc
    >::dynamic_bitset (dynamic_bitset< _WordT, _Alloc > && __b) [inline],
    [noexcept]

Move constructor. 😭🔥

✨ Member Function Documentation ✨

👑 all() const

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> bool std::tr2::dynamic_bitset< _WordT, _Alloc
    >::all () const [inline]

Tests whether all the bits are on. 👑

Returns True if all the bits are set.

🌈 any() const

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> bool std::tr2::dynamic_bitset< _WordT, _Alloc
    >::any () const [inline]

Tests whether any of the bits are on. 🌈

Returns True if at least one bit is set.

🦋 append(_BlockInputIterator __first, _BlockInputIterator __last)

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> template<typename _BlockInputIterator > void
    std::tr2::dynamic_bitset< _WordT, _Alloc >::append (_BlockInputIterator
    __first, _BlockInputIterator __last) [inline]

Append an iterator range of blocks. ✨

References std::tr2::dynamic_bitset< _WordT, _Alloc >::append().

🎀 append(block_type __block)

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> void std::tr2::dynamic_bitset< _WordT, _Alloc
    >::append (block_type __block) [inline]

Append a block. 💅

Referenced by std::tr2::dynamic_bitset< _WordT, _Alloc >::append().

🧹 clear()

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> void std::tr2::dynamic_bitset< _WordT, _Alloc
    >::clear () [inline]

Clear the bitset. 🧹

🔢 count() const

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> size_type std::tr2::dynamic_bitset< _WordT,
    _Alloc >::count () const [inline],  [noexcept]

Returns the number of bits which are set. 🔢

🫧 empty() const

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> bool std::tr2::dynamic_bitset< _WordT, _Alloc
    >::empty () const [inline],  [noexcept]

Returns true if the dynamic_bitset is empty. 🫧

🔎 find_first() const

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> size_type std::tr2::dynamic_bitset< _WordT,
    _Alloc >::find_first () const [inline]

Finds the index of the first 'on' bit. 🔎

Returns The index of the first bit set, or size() if not found.

See also find_next

🔍 find_next(size_t __prev) const

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> size_type std::tr2::dynamic_bitset< _WordT,
    _Alloc >::find_next (size_t __prev) const [inline]

Finds the index of the next 'on' bit after prev. 🔍

Returns The index of the next bit set, or size() if not found.

Parameters

  • __prev — Where to start searching.

See also find_first

🔁 flip()

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> dynamic_bitset & std::tr2::dynamic_bitset<
    _WordT, _Alloc >::flip () [inline]

Toggles every bit to its opposite value. 🔁

Referenced by std::tr2::dynamic_bitset< _WordT, _Alloc >::operator~().

🔂 flip(size_type __pos)

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> dynamic_bitset & std::tr2::dynamic_bitset<
    _WordT, _Alloc >::flip (size_type __pos) [inline]

Toggles a given bit to its opposite value. 🔂

Parameters

  • __pos — The index of the bit.

Exceptions

  • std::out_of_range — If __pos is bigger the size of the set.

🎁 get_allocator() const

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> allocator_type std::tr2::dynamic_bitset< _WordT,
    _Alloc >::get_allocator () const [inline],  [noexcept]

Return the allocator for the bitset. 🎁

Referenced by std::tr2::dynamic_bitset< _WordT, _Alloc >::operator=().

📏 max_size()

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> constexpr size_type std::tr2::dynamic_bitset<
    _WordT, _Alloc >::max_size () [inline],  [constexpr],  [noexcept]

Returns the maximum size of a dynamic_bitset object having the same type as *this. The real answer is max() * bits_per_block but is likely to overflow. 😭

References std::numeric_limits< _Tp >::max().

🚫 none() const

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> bool std::tr2::dynamic_bitset< _WordT, _Alloc
    >::none () const [inline]

The docs literally say “Tests whether any of the bits are on.” for none() 😭 (that’s the original wording, bestie).

Returns True if none of the bits are set.

🧱 num_blocks() const

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> size_type std::tr2::dynamic_bitset< _WordT,
    _Alloc >::num_blocks () const [inline],  [noexcept]

Returns the total number of blocks. 🧱

🧷 operator&=(const dynamic_bitset<_WordT, _Alloc>& __rhs)

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> dynamic_bitset & std::tr2::dynamic_bitset<
    _WordT, _Alloc >::operator&= (const dynamic_bitset< _WordT, _Alloc > &
    __rhs) [inline]

Operations on dynamic_bitsets. 🧷

Parameters

  • __rhs — A same-sized dynamic_bitset.

These should be self-explanatory. 💅

🧷 operator&=(dynamic_bitset<_WordT, _Alloc>&& __rhs)

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> dynamic_bitset & std::tr2::dynamic_bitset<
    _WordT, _Alloc >::operator&= (dynamic_bitset< _WordT, _Alloc > && __rhs)
    [inline]

Operations on dynamic_bitsets. 🧷

Parameters

  • __rhs — A same-sized dynamic_bitset.

These should be self-explanatory. 💅

References std::move().

➖ operator-=(const dynamic_bitset<_WordT, _Alloc>& __rhs)

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> dynamic_bitset & std::tr2::dynamic_bitset<
    _WordT, _Alloc >::operator-= (const dynamic_bitset< _WordT, _Alloc > &
    __rhs) [inline]

Operations on dynamic_bitsets. ➖

Parameters

  • __rhs — A same-sized dynamic_bitset.

These should be self-explanatory. 💅

⬅️ operator<<(size_type __pos) const

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> dynamic_bitset std::tr2::dynamic_bitset< _WordT,
    _Alloc >::operator<< (size_type __pos) const [inline]

Self-explanatory. 🫶

References std::tr2::dynamic_bitset< _WordT, _Alloc >::dynamic_bitset().

⬅️ operator<<=(size_type __pos)

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> dynamic_bitset & std::tr2::dynamic_bitset<
    _WordT, _Alloc >::operator<<= (size_type __pos) [inline]

Operations on dynamic_bitsets. ⬅️

Parameters

  • __pos — The number of places to shift.

These should be self-explanatory. 💅

📝 operator=(const dynamic_bitset<_WordT, _Alloc>&)

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> dynamic_bitset & std::tr2::dynamic_bitset<
    _WordT, _Alloc >::operator= (const dynamic_bitset< _WordT, _Alloc > &)
    [default]

Copy assignment operator. 📝

📝 operator=(dynamic_bitset<_WordT, _Alloc>&& __b)

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> dynamic_bitset & std::tr2::dynamic_bitset<
    _WordT, _Alloc >::operator= (dynamic_bitset< _WordT, _Alloc > && __b)
    [inline],  [noexcept]

Move assignment operator. 📝

References std::tr2::dynamic_bitset< _WordT, _Alloc >::get_allocator().

➡️ operator>>(size_type __pos) const

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> dynamic_bitset std::tr2::dynamic_bitset< _WordT,
    _Alloc >::operator>> (size_type __pos) const [inline]

Self-explanatory. 🫶

References std::tr2::dynamic_bitset< _WordT, _Alloc >::dynamic_bitset().

➡️ operator>>=(size_type __pos)

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> dynamic_bitset & std::tr2::dynamic_bitset<
    _WordT, _Alloc >::operator>>= (size_type __pos) [inline]

Operations on dynamic_bitsets. ➡️

Parameters

  • __pos — The number of places to shift.

These should be self-explanatory. 💅

🎯 operator[](size_type __pos)

template<typename _WordT  = unsigned long long, typename _Alloc  =
    std::allocator<_WordT>> reference std::tr2::dynamic_bitset< _WordT,
    _Alloc >::operator[] (size_type __pos) [inline]

Array-indexing support. 🎯

Parameters

  • __pos — Index into the dynamic_bitset.

Returns A bool for a 'const dynamic_bitset'. For non-const bitsets, an instance of the reference proxy class.

⚠️ Note These operators do no range checking and throw no exceptions, as required by DR 11 to the standard.

💅 operator[] (const one) — array-indexing support, periodt

   template<typename _WordT  = unsigned long long, typename _Alloc  =
       std::allocator<_WordT>> const_reference std::tr2::dynamic_bitset<
       _WordT, _Alloc >::operator[] (size_type __pos) const [inline]

Array-indexing support, bestie — this is the const flavor of indexing into the bitset.

Parameters

  • __pos — index into the dynamic_bitset.

Returns

A bool for a 'const dynamic_bitset'. For non-const bitsets, an instance of the reference proxy class.

Note 🚨 These operators do no range checking and throw no exceptions, as required by DR 11 to the standard. No cap, that's literally the rule.

🔥 operator^=

   template<typename _WordT  = unsigned long long, typename _Alloc  =
       std::allocator<_WordT>> dynamic_bitset & std::tr2::dynamic_bitset<
       _WordT, _Alloc >::operator^= (const dynamic_bitset< _WordT, _Alloc > &
       __rhs) [inline]

Operations on dynamic_bitsets — yes, this is one of them. 💅

Parameters

  • __rhs — a same-sized dynamic_bitset.

These should be self-explanatory (fr fr).

✨ operator|=

   template<typename _WordT  = unsigned long long, typename _Alloc  =
       std::allocator<_WordT>> dynamic_bitset & std::tr2::dynamic_bitset<
       _WordT, _Alloc >::operator|= (const dynamic_bitset< _WordT, _Alloc > &
       __rhs) [inline]

Operations on dynamic_bitsets — same iconic energy, different operator. 🌈

Parameters

  • __rhs — a same-sized dynamic_bitset.

These should be self-explanatory (no notes needed, bestie).

🦋 operator~

   template<typename _WordT  = unsigned long long, typename _Alloc  =
       std::allocator<_WordT>> dynamic_bitset std::tr2::dynamic_bitset< _WordT,
       _Alloc >::operator~ () const [inline]

See the no-argument flip(). That's the whole vibe.

References

std::tr2::dynamic_bitset< _WordT, _Alloc >::flip()

🎀 push_back

   template<typename _WordT  = unsigned long long, typename _Alloc  =
       std::allocator<_WordT>> void std::tr2::dynamic_bitset< _WordT, _Alloc
       >::push_back (bool __bit) [inline]

Push a bit onto the high end of the bitset. 🫶

References

std::tr2::dynamic_bitset< _WordT, _Alloc >::size()

🌸 reset()

   template<typename _WordT  = unsigned long long, typename _Alloc  =
       std::allocator<_WordT>> dynamic_bitset & std::tr2::dynamic_bitset<
       _WordT, _Alloc >::reset () [inline]

Sets every bit to false. Clean slate, zero drama. 💀

🍓 reset(size_type __pos)

   template<typename _WordT  = unsigned long long, typename _Alloc  =
       std::allocator<_WordT>> dynamic_bitset & std::tr2::dynamic_bitset<
       _WordT, _Alloc >::reset (size_type __pos) [inline]

Sets a given bit to false.

Parameters

  • __pos — the index of the bit.

Exceptions

  • std::out_of_range — if __pos is bigger the size of the set.

Same as writing set(__pos, false).

🧚 resize

   template<typename _WordT  = unsigned long long, typename _Alloc  =
       std::allocator<_WordT>> void std::tr2::dynamic_bitset< _WordT, _Alloc
       >::resize (size_type __nbits, bool __value = false) [inline]

Resize the bitset.

Referenced by

std::tr2::dynamic_bitset< _WordT, _Alloc >::dynamic_bitset(), and std::tr2::operator>>().

💜 set()

   template<typename _WordT  = unsigned long long, typename _Alloc  =
       std::allocator<_WordT>> dynamic_bitset & std::tr2::dynamic_bitset<
       _WordT, _Alloc >::set () [inline]

Sets every bit to true. Main character energy only. 👑

⭐ set(size_type __pos, bool __val = true)

   template<typename _WordT  = unsigned long long, typename _Alloc  =
       std::allocator<_WordT>> dynamic_bitset & std::tr2::dynamic_bitset<
       _WordT, _Alloc >::set (size_type __pos, bool __val = true) [inline]

Sets a given bit to a particular value.

Parameters

  • __pos — the index of the bit.
  • __val — either true or false, defaults to true.

Exceptions

  • std::out_of_range — if __pos is bigger the size of the set.

🌈 size

   template<typename _WordT  = unsigned long long, typename _Alloc  =
       std::allocator<_WordT>> size_type std::tr2::dynamic_bitset< _WordT,
       _Alloc >::size () const [inline],  [noexcept]

Returns the total number of bits.

Referenced by

std::tr2::operator>>(), and std::tr2::dynamic_bitset< _WordT, _Alloc >::push_back().

🫶 swap

   template<typename _WordT  = unsigned long long, typename _Alloc  =
       std::allocator<_WordT>> void std::tr2::dynamic_bitset< _WordT, _Alloc
       >::swap (dynamic_bitset< _WordT, _Alloc > & __b) [inline],  [noexcept]

Swap with another bitset. Tradesies, but make it efficient. ✨

🔥 test

   template<typename _WordT  = unsigned long long, typename _Alloc  =
       std::allocator<_WordT>> bool std::tr2::dynamic_bitset< _WordT, _Alloc
       >::test (size_type __pos) const [inline]

Tests the value of a bit.

Parameters

  • __pos — the index of a bit.

Returns

The value at __pos.

Exceptions

  • std::out_of_range — if __pos is bigger the size of the set.

💖 to_string

   template<typename _WordT  = unsigned long long, typename _Alloc  =
       std::allocator<_WordT>> template<typename _CharT  = char, typename
       _Traits  = std::char_traits<_CharT>, typename _Alloc1  =
       std::allocator<_CharT>> std::basic_string< _CharT, _Traits, _Alloc1 >
       std::tr2::dynamic_bitset< _WordT, _Alloc >::to_string (_CharT __zero =
       _CharT('0'), _CharT __one = _CharT('1')) const [inline]

Returns a character interpretation of the dynamic_bitset.

Returns

The string equivalent of the bits.

Note 📝 the ordering of the bits: decreasing character positions correspond to increasing bit positions (see the main class notes for an example). It's giving fancy, but it's consistent, okay?

🦋 to_ullong

   template<typename _WordT  = unsigned long long, typename _Alloc  =
       std::allocator<_WordT>> unsigned long long std::tr2::dynamic_bitset<
       _WordT, _Alloc >::to_ullong () const [inline]

Returns a numerical interpretation of the dynamic_bitset.

Returns

The integral equivalent of the bits.

Exceptions

  • std::overflow_error — if there are too many bits to be represented in an unsigned long.

🧚 to_ulong

   template<typename _WordT  = unsigned long long, typename _Alloc  =
       std::allocator<_WordT>> unsigned long std::tr2::dynamic_bitset< _WordT,
       _Alloc >::to_ulong () const [inline]

Returns a numerical interpretation of the dynamic_bitset.

Returns

The integral equivalent of the bits.

Exceptions

  • std::overflow_error — if there are too many bits to be represented in an unsigned long.

👑 Author

Generated automatically by Doxygen for libstdc++ from the source code.

That's the footer tea, bestie: source/version is the libstdc++ (3cxx) page situation, and the date is exactly whatever that footer printed — not me copying the line, just giving you the cute sign-off. Byeeee 💖✨🎀

📦 where this page comes from