Provided by: libstdc++6-4.5-doc_4.5.3-12ubuntu2_all bug

NAME

       std::bitset< _Nb > -

SYNOPSIS

       Inherits std::_Base_bitset<((_Nb)< 1?0:((_Nb)+(__CHAR_BIT__ *sizeof(unsigned
       long))-1)/(__CHAR_BIT__ *sizeof(unsigned long)))>.

   Classes
       class reference

   Public Member Functions
       bitset ()
       bitset (unsigned long long __val)
       template<class _CharT , class _Traits , class _Alloc > bitset (const std::basic_string<
           _CharT, _Traits, _Alloc > &__s, size_t __position=0)
       template<class _CharT , class _Traits , class _Alloc > bitset (const std::basic_string<
           _CharT, _Traits, _Alloc > &__s, size_t __position, size_t __n)
       template<class _CharT , class _Traits , class _Alloc > bitset (const std::basic_string<
           _CharT, _Traits, _Alloc > &__s, size_t __position, size_t __n, _CharT __zero, _CharT
           __one=_CharT('1'))
       bitset (const char *__str)
       size_t _Find_first () const
       size_t _Find_next (size_t __prev) const
       template<class _CharT , class _Traits > void _M_copy_from_ptr (const _CharT *, size_t,
           size_t, size_t, _CharT, _CharT)
       template<class _CharT , class _Traits , class _Alloc > void _M_copy_from_string (const
           std::basic_string< _CharT, _Traits, _Alloc > &__s, size_t __pos, size_t __n, _CharT
           __zero, _CharT __one)
       template<class _CharT , class _Traits , class _Alloc > void _M_copy_from_string (const
           std::basic_string< _CharT, _Traits, _Alloc > &__s, size_t __pos, size_t __n)
       template<class _CharT , class _Traits , class _Alloc > void _M_copy_to_string
           (std::basic_string< _CharT, _Traits, _Alloc > &, _CharT, _CharT) const
       template<class _CharT , class _Traits , class _Alloc > void _M_copy_to_string
           (std::basic_string< _CharT, _Traits, _Alloc > &__s) const
       bool all () const
       bool any () const
       size_t count () const
       bitset< _Nb > & flip ()
       bitset< _Nb > & flip (size_t __position)
       bool none () const
       bitset< _Nb > operator~ () const
       bitset< _Nb > & reset ()
       bitset< _Nb > & reset (size_t __position)
       bitset< _Nb > & set ()
       bitset< _Nb > & set (size_t __position, bool __val=true)
       size_t size () const
       bool test (size_t __position) const
       template<class _CharT , class _Traits , class _Alloc > std::basic_string< _CharT,
           _Traits, _Alloc > to_string () const "
       template<class _CharT , class _Traits , class _Alloc > std::basic_string< _CharT,
           _Traits, _Alloc > to_string (_CharT __zero, _CharT __one=_CharT('1')) const "
       template<class _CharT , class _Traits > std::basic_string< _CharT,
           _Traits, std::allocator
           < _CharT > > to_string () const "
       template<class _CharT , class _Traits > std::basic_string< _CharT,
           _Traits, std::allocator
           < _CharT > > to_string (_CharT __zero, _CharT __one=_CharT('1')) const "
       template<class _CharT > std::basic_string< _CharT,
           std::char_traits< _CharT >
           , std::allocator< _CharT > > to_string () const "
       template<class _CharT > std::basic_string< _CharT,
           std::char_traits< _CharT >
           , std::allocator< _CharT > > to_string (_CharT __zero, _CharT __one=_CharT('1')) const
           "
       std::basic_string< char,
           std::char_traits< char >
           , std::allocator< char > > to_string () const "
       std::basic_string< char,
           std::char_traits< char >
           , std::allocator< char > > to_string (char __zero, char __one= '1') const "
       unsigned long long to_ullong () const
       unsigned long to_ulong () const

           bitset< _Nb > & operator&= (const bitset< _Nb > &__rhs)
           bitset< _Nb > & operator|= (const bitset< _Nb > &__rhs)
           bitset< _Nb > & operator^= (const bitset< _Nb > &__rhs)

           bitset< _Nb > & operator<<= (size_t __position)
           bitset< _Nb > & operator>>= (size_t __position)

           bitset< _Nb > & _Unchecked_set (size_t __pos)
           bitset< _Nb > & _Unchecked_set (size_t __pos, int __val)
           bitset< _Nb > & _Unchecked_reset (size_t __pos)
           bitset< _Nb > & _Unchecked_flip (size_t __pos)
           bool _Unchecked_test (size_t __pos) const

           reference operator[] (size_t __position)
           bool operator[] (size_t __position) const

           bool operator== (const bitset< _Nb > &__rhs) const
           bool operator!= (const bitset< _Nb > &__rhs) const

           bitset< _Nb > operator<< (size_t __position) const
           bitset< _Nb > operator>> (size_t __position) const

   Private Types
       typedef unsigned long _WordT

   Private Member Functions
       size_t _M_are_all_aux () const
       void _M_do_and (const _Base_bitset< _Nw > &__x)
       size_t _M_do_count () const
       size_t _M_do_find_first (size_t __not_found) const
       size_t _M_do_find_next (size_t __prev, size_t __not_found) const
       void _M_do_flip ()
       void _M_do_left_shift (size_t __shift)
       void _M_do_or (const _Base_bitset< _Nw > &__x)
       void _M_do_reset ()
       void _M_do_right_shift (size_t __shift)
       void _M_do_set ()
       unsigned long long _M_do_to_ullong () const
       unsigned long _M_do_to_ulong () const
       void _M_do_xor (const _Base_bitset< _Nw > &__x)
       const _WordT * _M_getdata () const
       _WordT & _M_getword (size_t __pos)
       _WordT _M_getword (size_t __pos) const
       _WordT & _M_hiword ()
       _WordT _M_hiword () const
       bool _M_is_any () const
       bool _M_is_equal (const _Base_bitset< _Nw > &__x) const

   Static Private Member Functions
       static _WordT _S_maskbit (size_t __pos)
       static size_t _S_whichbit (size_t __pos)
       static size_t _S_whichbyte (size_t __pos)
       static size_t _S_whichword (size_t __pos)

   Private Attributes
       _WordT _M_w [_Nw]

   Friends
       class hash
       class reference

Detailed Description

   template<size_t _Nb>class std::bitset< _Nb >
       The bitset class represents a fixed-size sequence of bits.

       (Note that bitset does not meet the formal requirements of a container. Mainly, it lacks
       iterators.)

       The template argument, Nb, may be any non-negative number, specifying the number of bits
       (e.g., '0', '12', '1024*1024').

       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 bitset as a simple array of bits, be aware that your mental picture is
       reversed: a 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 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 <bitset>
            #include <iostream>
            #include <sstream>

            using namespace std;

            int main()
            {
                long         a = 'a';
                bitset<10>   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] << ' but0
                     << 'index 3 in the bitset is ' << b[3] << endl;
            }

       Also see: http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt12ch33s02.html for a
       description of extensions.

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

       Extra confusion can result due to the fact that the storage for _Base_bitset is a regular
       array, and is indexed as such. This is carefully encapsulated.

       Definition at line 709 of file bitset.

Constructor & Destructor Documentation

   template<size_t _Nb> std::bitset< _Nb >::bitset () [inline]
       All bits set to zero.

       Definition at line 803 of file bitset.

   template<size_t _Nb> std::bitset< _Nb >::bitset (unsigned long long__val) [inline]
       Initial bits bitwise-copied from a single word (others set to zero).

       Definition at line 808 of file bitset.

   template<size_t _Nb> template<class _CharT , class _Traits , class _Alloc > std::bitset< _Nb
       >::bitset (const std::basic_string< _CharT, _Traits, _Alloc > &__s, size_t__position = 0)
       [inline, explicit]
       Use a subset of a string. Parameters:
           s A string of 0 and 1 characters.
           position Index of the first character in s to use; defaults to zero.

       Exceptions:
           std::out_of_range If pos is bigger the size of s.
           std::invalid_argument If a character appears in the string which is neither 0 nor 1.

       Definition at line 826 of file bitset.

       References std::basic_string< _CharT, _Traits, _Alloc >::size().

   template<size_t _Nb> template<class _CharT , class _Traits , class _Alloc > std::bitset< _Nb
       >::bitset (const std::basic_string< _CharT, _Traits, _Alloc > &__s, size_t__position,
       size_t__n) [inline]
       Use a subset of a string. Parameters:
           s A string of 0 and 1 characters.
           position Index of the first character in s to use.
           n The number of characters to copy.

       Exceptions:
           std::out_of_range If pos is bigger the size of s.
           std::invalid_argument If a character appears in the string which is neither 0 nor 1.

       Definition at line 848 of file bitset.

       References std::basic_string< _CharT, _Traits, _Alloc >::size().

   template<size_t _Nb> std::bitset< _Nb >::bitset (const char *__str) [inline, explicit]
       Construct from a string. Parameters:
           str A string of 0 and 1 characters.

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

       Definition at line 880 of file bitset.

Member Function Documentation

   template<size_t _Nb> bool std::bitset< _Nb >::all () const [inline]
       Tests whether all the bits are on. Returns:
           True if all the bits are set.

       Definition at line 1267 of file bitset.

   template<size_t _Nb> bool std::bitset< _Nb >::any () const [inline]
       Tests whether any of the bits are on. Returns:
           True if at least one bit is set.

       Definition at line 1275 of file bitset.

   template<size_t _Nb> size_t std::bitset< _Nb >::count () const [inline]
       Returns the number of bits which are set.

       Definition at line 1227 of file bitset.

   template<size_t _Nb> bitset<_Nb>& std::bitset< _Nb >::flip () [inline]
       Toggles every bit to its opposite value.

       Definition at line 1054 of file bitset.

       Referenced by std::bitset< _Nb >::operator~().

   template<size_t _Nb> bitset<_Nb>& std::bitset< _Nb >::flip (size_t__position) [inline]
       Toggles a given bit to its opposite value. Parameters:
           position The index of the bit.

       Exceptions:
           std::out_of_range If pos is bigger the size of the set.

       Definition at line 1067 of file bitset.

   template<size_t _Nb> bool std::bitset< _Nb >::none () const [inline]
       Tests whether any of the bits are on. Returns:
           True if none of the bits are set.

       Definition at line 1283 of file bitset.

   template<size_t _Nb> bool std::bitset< _Nb >::operator!= (const bitset< _Nb > &__rhs) const
       [inline]
       These comparisons for equality/inequality are, well, bitwise.

       Definition at line 1242 of file bitset.

   template<size_t _Nb> bitset<_Nb>& std::bitset< _Nb >::operator&= (const bitset< _Nb > &__rhs)
       [inline]
       Operations on bitsets. Parameters:
           rhs A same-sized bitset.

       These should be self-explanatory.

       Definition at line 901 of file bitset.

   template<size_t _Nb> bitset<_Nb> std::bitset< _Nb >::operator<< (size_t__position) const
       [inline]
       Self-explanatory.

       Definition at line 1289 of file bitset.

   template<size_t _Nb> bitset<_Nb>& std::bitset< _Nb >::operator<<= (size_t__position) [inline]
       Operations on bitsets. Parameters:
           position The number of places to shift.

       These should be self-explanatory.

       Definition at line 930 of file bitset.

   template<size_t _Nb> bool std::bitset< _Nb >::operator== (const bitset< _Nb > &__rhs) const
       [inline]
       These comparisons for equality/inequality are, well, bitwise.

       Definition at line 1238 of file bitset.

   template<size_t _Nb> bitset<_Nb> std::bitset< _Nb >::operator>> (size_t__position) const
       [inline]
       Self-explanatory.

       Definition at line 1293 of file bitset.

   template<size_t _Nb> bitset<_Nb>& std::bitset< _Nb >::operator>>= (size_t__position) [inline]
       Operations on bitsets. Parameters:
           position The number of places to shift.

       These should be self-explanatory.

       Definition at line 943 of file bitset.

   template<size_t _Nb> reference std::bitset< _Nb >::operator[] (size_t__position) [inline]
       Array-indexing support. Parameters:
           position Index into the bitset.

       Returns:
           A bool for a const 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.

       _GLIBCXX_RESOLVE_LIB_DEFECTS Note that this implementation already resolves DR 11 (items 1
       and 2), but does not do the range-checking required by that DR's resolution. -pme The DR
       has since been changed: range-checking is a precondition (users' responsibility), and
       these functions must not throw. -pme

       Definition at line 1095 of file bitset.

   template<size_t _Nb> bool std::bitset< _Nb >::operator[] (size_t__position) const [inline]
       Array-indexing support. Parameters:
           position Index into the bitset.

       Returns:
           A bool for a const 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.

       _GLIBCXX_RESOLVE_LIB_DEFECTS Note that this implementation already resolves DR 11 (items 1
       and 2), but does not do the range-checking required by that DR's resolution. -pme The DR
       has since been changed: range-checking is a precondition (users' responsibility), and
       these functions must not throw. -pme

       Definition at line 1099 of file bitset.

   template<size_t _Nb> bitset<_Nb>& std::bitset< _Nb >::operator^= (const bitset< _Nb > &__rhs)
       [inline]
       Operations on bitsets. Parameters:
           rhs A same-sized bitset.

       These should be self-explanatory.

       Definition at line 915 of file bitset.

   template<size_t _Nb> bitset<_Nb>& std::bitset< _Nb >::operator|= (const bitset< _Nb > &__rhs)
       [inline]
       Operations on bitsets. Parameters:
           rhs A same-sized bitset.

       These should be self-explanatory.

       Definition at line 908 of file bitset.

   template<size_t _Nb> bitset<_Nb> std::bitset< _Nb >::operator~ () const [inline]
       See the no-argument flip().

       Definition at line 1076 of file bitset.

       References std::bitset< _Nb >::flip().

   template<size_t _Nb> bitset<_Nb>& std::bitset< _Nb >::reset () [inline]
       Sets every bit to false.

       Definition at line 1029 of file bitset.

   template<size_t _Nb> bitset<_Nb>& std::bitset< _Nb >::reset (size_t__position) [inline]
       Sets a given bit to false. Parameters:
           position 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).

       Definition at line 1043 of file bitset.

   template<size_t _Nb> bitset<_Nb>& std::bitset< _Nb >::set () [inline]
       Sets every bit to true.

       Definition at line 1004 of file bitset.

   template<size_t _Nb> bitset<_Nb>& std::bitset< _Nb >::set (size_t__position, bool__val = true)
       [inline]
       Sets a given bit to a particular value. Parameters:
           position 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.

       Definition at line 1018 of file bitset.

   template<size_t _Nb> size_t std::bitset< _Nb >::size () const [inline]
       Returns the total number of bits.

       Definition at line 1232 of file bitset.

   template<size_t _Nb> bool std::bitset< _Nb >::test (size_t__position) const [inline]
       Tests the value of a bit. Parameters:
           position The index of a bit.

       Returns:
           The value at pos.

       Exceptions:
           std::out_of_range If pos is bigger the size of the set.

       Definition at line 1253 of file bitset.

   template<size_t _Nb> template<class _CharT , class _Traits , class _Alloc >
       std::basic_string<_CharT, _Traits, _Alloc> std::bitset< _Nb >::to_string () const [inline]
       Returns a character interpretation of the 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).

       Definition at line 1129 of file bitset.

   template<size_t _Nb> unsigned long std::bitset< _Nb >::to_ulong () const [inline]
       Returns a numerical interpretation of the 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.

       Definition at line 1110 of file bitset.

Author

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