std::tr2::dynamic_bitset< _WordT, _Alloc > - The dynamic_bitset class represents a sequence of bits.

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

                                                    libstdc++   std::tr2::dynamic_bitset<_WordT,_Alloc>(3cxx)

template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>std::tr2::dynamic_bitset<_WordT,_Alloc>::dynamic_bitset()[default]
       All bits set to zero.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>std::tr2::dynamic_bitset<_WordT,_Alloc>::dynamic_bitset(constallocator_type&__alloc)[inline],[explicit]
       All bits set to zero.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>std::tr2::dynamic_bitset<_WordT,_Alloc>::dynamic_bitset(size_type__nbits,unsignedlonglong__val=0ULL,constallocator_type&__alloc=allocator_type())[inline],[explicit]
       Initial bits bitwise-copied from a single word (others set to zero).

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>template<typename_CharT,typename_Traits,typename_Alloc1>std::tr2::dynamic_bitset<_WordT,_Alloc>::dynamic_bitset(conststd::basic_string<_CharT,_Traits,_Alloc1>&__str,typenamebasic_string<_CharT,_Traits,_Alloc1>::size_type__pos=0,typenamebasic_string<_CharT,_Traits,_Alloc1>::size_type__n=std::basic_string<_CharT,_Traits,_Alloc1>::npos,_CharT__zero=_CharT('0'),_CharT__one=_CharT('1'),constallocator_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.

       Exceptionsstd::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'.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>std::tr2::dynamic_bitset<_WordT,_Alloc>::dynamic_bitset(constchar*__str,constallocator_type&__alloc=allocator_type())[inline],[explicit]
       Construct from a string.

       Parameters__str A string of '0' and '1' characters.
           __alloc An allocator.

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

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>std::tr2::dynamic_bitset<_WordT,_Alloc>::dynamic_bitset(constdynamic_bitset<_WordT,_Alloc>&)[default]
       Copy constructor.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>std::tr2::dynamic_bitset<_WordT,_Alloc>::dynamic_bitset(dynamic_bitset<_WordT,_Alloc>&&__b)[inline],[noexcept]
       Move constructor.

template<typename_WordT=unsignedlonglong,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.

template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>boolstd::tr2::dynamic_bitset<_WordT,_Alloc>::all()const[inline]
       Tests whether all the bits are on.

       Returns
           True if all the bits are set.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>boolstd::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.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>template<typename_BlockInputIterator>voidstd::tr2::dynamic_bitset<_WordT,_Alloc>::append(_BlockInputIterator__first,_BlockInputIterator__last)[inline]
       Append an iterator range of blocks.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>voidstd::tr2::dynamic_bitset<_WordT,_Alloc>::append(block_type__block)[inline]
       Append a block.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>voidstd::tr2::dynamic_bitset<_WordT,_Alloc>::clear()[inline]
       Clear the bitset.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>size_typestd::tr2::dynamic_bitset<_WordT,_Alloc>::count()const[inline],[noexcept]
       Returns the number of bits which are set.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>boolstd::tr2::dynamic_bitset<_WordT,_Alloc>::empty()const[inline],[noexcept]
       Returns true if the dynamic_bitset is empty.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>size_typestd::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.

       Seealso
           find_next

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>size_typestd::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.

       Seealso
           find_first

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>dynamic_bitset&std::tr2::dynamic_bitset<_WordT,_Alloc>::flip()[inline]
       Toggles every bit to its opposite value.

   template<typename_WordT=unsignedlonglong,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.

       Exceptionsstd::out_of_range If __pos is bigger the size of the set.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>allocator_typestd::tr2::dynamic_bitset<_WordT,_Alloc>::get_allocator()const[inline],[noexcept]
       Return the allocator for the bitset.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>constexprsize_typestd::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.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>boolstd::tr2::dynamic_bitset<_WordT,_Alloc>::none()const[inline]
       Tests whether any of the bits are on.

       Returns
           True if none of the bits are set.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>size_typestd::tr2::dynamic_bitset<_WordT,_Alloc>::num_blocks()const[inline],[noexcept]
       Returns the total number of blocks.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>dynamic_bitset&std::tr2::dynamic_bitset<_WordT,_Alloc>::operator&=(constdynamic_bitset<_WordT,_Alloc>&__rhs)[inline]
       Operations on dynamic_bitsets.

       Parameters__rhs A same-sized dynamic_bitset.

       These should be self-explanatory.

   template<typename_WordT=unsignedlonglong,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.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>dynamic_bitset&std::tr2::dynamic_bitset<_WordT,_Alloc>::operator-=(constdynamic_bitset<_WordT,_Alloc>&__rhs)[inline]
       Operations on dynamic_bitsets.

       Parameters__rhs A same-sized dynamic_bitset.

       These should be self-explanatory.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>dynamic_bitsetstd::tr2::dynamic_bitset<_WordT,_Alloc>::operator<<(size_type__pos)const[inline]
       Self-explanatory.

   template<typename_WordT=unsignedlonglong,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.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>dynamic_bitset&std::tr2::dynamic_bitset<_WordT,_Alloc>::operator=(constdynamic_bitset<_WordT,_Alloc>&)[default]
       Copy assignment operator.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>dynamic_bitset&std::tr2::dynamic_bitset<_WordT,_Alloc>::operator=(dynamic_bitset<_WordT,_Alloc>&&__b)[inline],[noexcept]
       Move assignment operator.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>dynamic_bitsetstd::tr2::dynamic_bitset<_WordT,_Alloc>::operator>>(size_type__pos)const[inline]
       Self-explanatory.

   template<typename_WordT=unsignedlonglong,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.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>referencestd::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.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>const_referencestd::tr2::dynamic_bitset<_WordT,_Alloc>::operator[](size_type__pos)const[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.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>dynamic_bitset&std::tr2::dynamic_bitset<_WordT,_Alloc>::operator^=(constdynamic_bitset<_WordT,_Alloc>&__rhs)[inline]
       Operations on dynamic_bitsets.

       Parameters__rhs A same-sized dynamic_bitset.

       These should be self-explanatory.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>dynamic_bitset&std::tr2::dynamic_bitset<_WordT,_Alloc>::operator|=(constdynamic_bitset<_WordT,_Alloc>&__rhs)[inline]
       Operations on dynamic_bitsets.

       Parameters__rhs A same-sized dynamic_bitset.

       These should be self-explanatory.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>dynamic_bitsetstd::tr2::dynamic_bitset<_WordT,_Alloc>::operator~()const[inline]
       See the no-argument flip().

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>voidstd::tr2::dynamic_bitset<_WordT,_Alloc>::push_back(bool__bit)[inline]
       Push a bit onto the high end of the bitset.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>dynamic_bitset&std::tr2::dynamic_bitset<_WordT,_Alloc>::reset()[inline]
       Sets every bit to false.

   template<typename_WordT=unsignedlonglong,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.

       Exceptionsstd::out_of_range If __pos is bigger the size of the set.

       Same as writing set(__pos, false).

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>voidstd::tr2::dynamic_bitset<_WordT,_Alloc>::resize(size_type__nbits,bool__value=false)[inline]
       Resize the bitset.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>dynamic_bitset&std::tr2::dynamic_bitset<_WordT,_Alloc>::set()[inline]
       Sets every bit to true.

   template<typename_WordT=unsignedlonglong,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.

       Exceptionsstd::out_of_range If __pos is bigger the size of the set.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>size_typestd::tr2::dynamic_bitset<_WordT,_Alloc>::size()const[inline],[noexcept]
       Returns the total number of bits.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>voidstd::tr2::dynamic_bitset<_WordT,_Alloc>::swap(dynamic_bitset<_WordT,_Alloc>&__b)[inline],[noexcept]
       Swap with another bitset.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>boolstd::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.

       Exceptionsstd::out_of_range If __pos is bigger the size of the set.

   template<typename_WordT=unsignedlonglong,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).

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>unsignedlonglongstd::tr2::dynamic_bitset<_WordT,_Alloc>::to_ullong()const[inline]
       Returns a numerical interpretation of the dynamic_bitset.

       Returns
           The integral equivalent of the bits.

       Exceptionsstd::overflow_error If there are too many bits to be represented in an unsigned long.

   template<typename_WordT=unsignedlonglong,typename_Alloc=std::allocator<_WordT>>unsignedlongstd::tr2::dynamic_bitset<_WordT,_Alloc>::to_ulong()const[inline]
       Returns a numerical interpretation of the dynamic_bitset.

       Returns
           The integral equivalent of the bits.

       Exceptionsstd::overflow_error If there are too many bits to be represented in an unsigned long.

       std::tr2::dynamic_bitset< _WordT, _Alloc > - The dynamic_bitset class represents a sequence of bits.

       #include <dynamic_bitset>

       Inherits std::tr2::__dynamic_bitset_base<_WordT,_Alloc>.

   Classes
       class referencePublicTypestypedef__dynamic_bitset_base< _WordT, _Alloc > _Basetypedef _Alloc allocator_typetypedef _WordT block_typetypedef bool const_referencetypedef size_t size_typePublicMemberFunctionsdynamic_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.
       template<typename _CharT , typename _Traits , typename _Alloc1 > dynamic_bitset (const std::basic_string<
           _CharT, _Traits, _Alloc1 > &__str, typenamebasic_string< _CharT, _Traits, _Alloc1 >::size_type
           __pos=0, typenamebasic_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())
           Use a subset of a string.
       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).
       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'))
       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'))
       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.
       template<typename_BlockInputIterator > voidappend (_BlockInputIterator __first, _BlockInputIterator
           __last)
           Append an iterator range of blocks.
       voidappend (block_type __block)
           Append a block.
       voidappend (initializer_list< block_type > __il)
       voidclear ()
           Clear 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_bitsetoperator~ () const
           See the no-argument flip().
       voidpush_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.
       voidresize (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.
       voidswap (dynamic_bitset &__b) noexcept
           Swap with another bitset.
       bool test (size_type __pos) const
           Tests the value of a bit.
       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
           Returns a character interpretation of the dynamic_bitset.
       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.

           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.

           referenceoperator[] (size_type __pos)
               Array-indexing support.
           const_reference operator[] (size_type __pos) const
               Array-indexing support.

           dynamic_bitsetoperator<< (size_type __pos) const
               Self-explanatory.
           dynamic_bitsetoperator>> (size_type __pos) const
               Self-explanatory.

   StaticPublicAttributesstatic const size_type bits_per_blockstatic const size_type nposFriends
       bool operator< (const dynamic_bitset &__lhs, const dynamic_bitset &__rhs) noexcept
       bool operator== (const dynamic_bitset &__lhs, const dynamic_bitset &__rhs) noexcept
       classreference