Public Types
typedef _If< _Bits<=32, _Uint32t, _ULonglong >::type _Ty;class reference{friend class bitset< _Bits >;public:~reference() _NOEXCEPT{}reference &operator=(bool _Val) _NOEXCEPT{_Pbitset->	set(_Mypos, _Val)

Public Member Functions
reference &	operator= (const reference &_Bitref) _NOEXCEPT

reference &	flip () _NOEXCEPT

bool	operator~ () const _NOEXCEPT

	operator bool () const _NOEXCEPT

Public Attributes
return *	this

Private Types
enum	: ptrdiff_t { _Bitsperword = (ptrdiff_t)(CHAR_BIT * sizeof (_Ty)), _Words }

Private Member Functions
	reference () _NOEXCEPT

	reference (bitset< _Bits > &_Bitset, size_t _Pos)

constexpr bool	_Subscript (size_t _Pos) const

constexpr bool	operator[] (size_t _Pos) const

reference	operator[] (size_t _Pos)

constexpr	bitset () _NOEXCEPT

constexpr	bitset (_ULonglong _Val) _NOEXCEPT

template<class _Elem , class _Tr , class _Alloc >
	bitset (const basic_string< _Elem, _Tr, _Alloc > &_Str, _BITSET_SIZE_TYPE _Pos=0, _BITSET_SIZE_TYPE _Count=basic_string< _Elem, _Tr, _Alloc >::npos, _Elem _E0=(_Elem)'0', _Elem _E1=(_Elem)'1')

template<class _Elem >
	bitset (const _Elem *_Ptr, typename basic_string< _Elem >::size_type _Count=basic_string< _Elem >::npos, _Elem _E0=(_Elem)'0', _Elem _E1=(_Elem)'1')

template<class _Elem , class _Tr , class _Alloc >
void	_Construct (const basic_string< _Elem, _Tr, _Alloc > &_Str, _BITSET_SIZE_TYPE _Pos, _BITSET_SIZE_TYPE _Count, _Elem _E0, _Elem _E1)

bitset &	operator&= (const bitset &_Right) _NOEXCEPT

bitset &	operator\|= (const bitset &_Right) _NOEXCEPT

bitset &	operator^= (const bitset &_Right) _NOEXCEPT

bitset &	operator<<= (size_t _Pos) _NOEXCEPT

bitset &	operator>>= (size_t _Pos) _NOEXCEPT

bitset &	set () _NOEXCEPT

bitset &	set (size_t _Pos, bool _Val=true)

bitset &	reset () _NOEXCEPT

bitset &	reset (size_t _Pos)

bitset	operator~ () const _NOEXCEPT

bitset &	flip () _NOEXCEPT

bitset &	flip (size_t _Pos)

unsigned long	to_ulong () const

_ULonglong	to_ullong () const

template<class _Elem = char, class _Tr = char_traits<_Elem>, class _Alloc = allocator<_Elem>>
basic_string< _Elem, _Tr, _Alloc >	to_string (_Elem _E0=(_Elem)'0', _Elem _E1=(_Elem)'1') const

size_t	count () const _NOEXCEPT

constexpr size_t	size () const _NOEXCEPT

size_t	hash () const

bool	operator== (const bitset &_Right) const _NOEXCEPT

bool	operator!= (const bitset &_Right) const _NOEXCEPT

bool	test (size_t _Pos) const

bool	any () const _NOEXCEPT

bool	none () const _NOEXCEPT

bool	all () const _NOEXCEPT

bitset	operator<< (size_t _Pos) const _NOEXCEPT

bitset	operator>> (size_t _Pos) const _NOEXCEPT

_Ty	_Getword (size_t _Wpos) const

void	_Tidy (_Ty _Wordval=0)

void	_Trim ()

void	_Trim_if (true_type)

void	_Trim_if (false_type)

void	_Xinv () const

void	_Xoflo () const

void	_Xran () const

Static Private Member Functions
static void	_Validate (size_t)

Private Attributes
bitset< _Bits > *	_Pbitset

size_t	_Mypos

_Ty	_Array [_Words+1]

Static Private Attributes
static constexpr bool	_Need_mask = _Bits < CHAR_BIT * sizeof (_ULonglong)

static constexpr _ULonglong	_Mask = (1ULL << (_Need_mask ? _Bits : 0)) - 1ULL

Member Typedef Documentation

template<size_t _Bits>

typedef _If<_Bits <= 32, _Uint32t, _ULonglong>::type _Ty; class reference { friend class bitset<_Bits>; public: ~reference() _NOEXCEPT { } reference& operator=(bool _Val) _NOEXCEPT { _Pbitset-> bitset< _Bits >::set(_Mypos, _Val)

Member Enumeration Documentation

template<size_t _Bits>

anonymous enum : ptrdiff_t

private

Enumerator
_Bitsperword
_Words

          : ptrdiff_t
 
         {   // parameters for packing bits into words
         _Bitsperword = (ptrdiff_t)(CHAR_BIT * sizeof (_Ty)),
         _Words = (ptrdiff_t)(_Bits == 0
             ? 0 : (_Bits - 1) / _Bitsperword)}; // NB: number of words - 1

Constructor & Destructor Documentation

template<size_t _Bits>

constexpr bitset< _Bits >::bitset ( )

inlineprivate

         : _Array()
         {   // construct with all false values
         }

template<size_t _Bits>

constexpr bitset< _Bits >::bitset ( _ULonglong _Val )

inlineprivate

         : _Array{static_cast<_Ty>(_Need_mask ? _Val & _Mask : _Val)}
         {   // construct from bits in unsigned long long
         }

template<size_t _Bits>

template<class _Elem , class _Tr , class _Alloc >

bitset< _Bits >::bitset	(	const basic_string< _Elem, _Tr, _Alloc > &	_Str,
		_BITSET_SIZE_TYPE	_Pos = `0`,
		_BITSET_SIZE_TYPE	_Count = `basic_string<_Elem, _Tr, _Alloc>::npos`,
		_Elem	_E0 = `(_Elem)'0'`,
		_Elem	_E1 = `(_Elem)'1'`
	)

inlineexplicitprivate

         {   // construct from [_Pos, _Pos + _Count) elements in string
         _Construct(_Str, _Pos, _Count, _E0, _E1);
         }

template<size_t _Bits>

template<class _Elem >

bitset< _Bits >::bitset	(	const _Elem *	_Ptr,
		typename basic_string< _Elem >::size_type	_Count = `basic_string<_Elem>::npos`,
		_Elem	_E0 = `(_Elem)'0'`,
		_Elem	_E1 = `(_Elem)'1'`
	)

inlineexplicitprivate

         {   // initialize from NTBS
         _Construct(
             _Count == basic_string<_Elem>::npos
                 ? basic_string<_Elem>(_Ptr)
                 : basic_string<_Elem>(_Ptr, _Count),
             0, _Count, _E0, _E1);
         }

Member Function Documentation

template<size_t _Bits>

template<class _Elem , class _Tr , class _Alloc >

void bitset< _Bits >::_Construct	(	const basic_string< _Elem, _Tr, _Alloc > &	_Str,
		_BITSET_SIZE_TYPE	_Pos,
		_BITSET_SIZE_TYPE	_Count,
		_Elem	_E0,
		_Elem	_E1
	)

inlineprivate

         {   // initialize from [_Pos, _Pos + _Count) elements in string
         if (_Str.size() < _Pos)
             _Xran();    // _Pos off end
         if (_Str.size() - _Pos < _Count)
             _Count = _Str.size() - _Pos;    // trim _Count to size
 
         typename basic_string<_Elem, _Tr, _Alloc>::size_type _Num;
         for (_Num = 0; _Num < _Count; ++_Num)
             if (!_Tr::eq(_Str[_Pos + _Num], _E0)
                 && !_Tr::eq(_Str[_Pos + _Num], _E1))
                 _Xinv();
 
         if (_Bits < _Count)
             _Count = _Bits; // trim _Count to length of bitset
         _Tidy();
 
         for (_Pos += _Count, _Num = 0; _Num < _Count; ++_Num)
             if (_Tr::eq(_Str[--_Pos], _E1))
                 set(_Num);
         }

template<size_t _Bits>

_Ty bitset< _Bits >::_Getword ( size_t _Wpos ) const

inlineprivate

         {   // get word at _Wpos
         return (_Array[_Wpos]);
         }

template<size_t _Bits>

constexpr bool bitset< _Bits >::_Subscript ( size_t _Pos ) const

inlineprivate

         {   // subscript nonmutable sequence
         return ((_Array[_Pos / _Bitsperword]
             & ((_Ty)1 << _Pos % _Bitsperword)) != 0);
         }

template<size_t _Bits>

void bitset< _Bits >::_Tidy ( _Ty _Wordval = 0 )

inlineprivate

         {   // set all words to _Wordval
         for (ptrdiff_t _Wpos = _Words; 0 <= _Wpos; --_Wpos)
             _Array[_Wpos] = _Wordval;
         if (_Wordval != 0)
             _Trim();
         }

template<size_t _Bits>

void bitset< _Bits >::_Trim ( )

inlineprivate

         {   // clear any trailing bits in last word
         _Trim_if(bool_constant<_Bits == 0 || _Bits % _Bitsperword != 0>());
         }

template<size_t _Bits>

void bitset< _Bits >::_Trim_if ( true_type )

inlineprivate

         {   // bits to trim, remove them
         _Array[_Words] &= ((_Ty)1 << _Bits % _Bitsperword) - 1;
         }

template<size_t _Bits>

void bitset< _Bits >::_Trim_if ( false_type )

inlineprivate

471 { // no bits to trim, do nothing

472 }

template<size_t _Bits>

static void bitset< _Bits >::_Validate ( size_t )

inlinestaticprivate

95 { // (don't) verify that _Pos is within bounds

96 }

template<size_t _Bits>

void bitset< _Bits >::_Xinv ( ) const

inlineprivate

         {   // report invalid string element in bitset conversion
         _Xinvalid_argument("invalid bitset<N> char");
         }

template<size_t _Bits>

void bitset< _Bits >::_Xoflo ( ) const

inlineprivate

         {   // report converted value too big to represent
         _Xoverflow_error("bitset<N> overflow");
         }

template<size_t _Bits>

void bitset< _Bits >::_Xran ( ) const

inlineprivate

         {   // report bit index out of range
         _Xout_of_range("invalid bitset<N> position");
         }

template<size_t _Bits>

bool bitset< _Bits >::all ( ) const

inlineprivate

         {   // test if all bits set
         return (count() == size());
         }

template<size_t _Bits>

bool bitset< _Bits >::any ( ) const

inlineprivate

         {   // test if any bits are set
         for (ptrdiff_t _Wpos = _Words; 0 <= _Wpos; --_Wpos)
             if (_Array[_Wpos] != 0)
                 return (true);
         return (false);
         }

template<size_t _Bits>

size_t bitset< _Bits >::count ( ) const

inlineprivate

         {   // count number of set bits
         const char *const _Bitsperbyte =
             "\0\1\1\2\1\2\2\3\1\2\2\3\2\3\3\4"
             "\1\2\2\3\2\3\3\4\2\3\3\4\3\4\4\5"
             "\1\2\2\3\2\3\3\4\2\3\3\4\3\4\4\5"
             "\2\3\3\4\3\4\4\5\3\4\4\5\4\5\5\6"
             "\1\2\2\3\2\3\3\4\2\3\3\4\3\4\4\5"
             "\2\3\3\4\3\4\4\5\3\4\4\5\4\5\5\6"
             "\2\3\3\4\3\4\4\5\3\4\4\5\4\5\5\6"
             "\3\4\4\5\4\5\5\6\4\5\5\6\5\6\6\7"
             "\1\2\2\3\2\3\3\4\2\3\3\4\3\4\4\5"
             "\2\3\3\4\3\4\4\5\3\4\4\5\4\5\5\6"
             "\2\3\3\4\3\4\4\5\3\4\4\5\4\5\5\6"
             "\3\4\4\5\4\5\5\6\4\5\5\6\5\6\6\7"
             "\2\3\3\4\3\4\4\5\3\4\4\5\4\5\5\6"
             "\3\4\4\5\4\5\5\6\4\5\5\6\5\6\6\7"
             "\3\4\4\5\4\5\5\6\4\5\5\6\5\6\6\7"
             "\4\5\5\6\5\6\6\7\5\6\6\7\6\7\7\x8";
         const unsigned char *_Ptr =
             (const unsigned char *)(const void *)_Array;
         const unsigned char *const _End = _Ptr + sizeof (_Array);
         size_t _Val = 0;
         for ( ; _Ptr != _End; ++_Ptr)
             _Val += _Bitsperbyte[*_Ptr];
         return (_Val);
         }

template<size_t _Bits>

reference& bitset< _Bits >::flip ( )

inline

             {   // complement stored element
             _Pbitset->flip(_Mypos);
             return (*this);
             }

template<size_t _Bits>

bitset& bitset< _Bits >::flip ( )

inlineprivate

         {   // flip all bits
         for (ptrdiff_t _Wpos = _Words; 0 <= _Wpos; --_Wpos)
             _Array[_Wpos] = (_Ty)~_Array[_Wpos];
 
         _Trim();
         return (*this);
         }

template<size_t _Bits>

bitset& bitset< _Bits >::flip ( size_t _Pos )

inlineprivate

         {   // flip bit at _Pos
         if (_Bits <= _Pos)
             _Xran();    // _Pos off end
         _Array[_Pos / _Bitsperword] ^= (_Ty)1 << _Pos % _Bitsperword;
         return (*this);
         }

template<size_t _Bits>

size_t bitset< _Bits >::hash ( ) const

inlineprivate

         {   // hash bits to size_t value by pseudorandomizing transform
         return (_Hash_seq((const unsigned char *)_Array,
             sizeof (_Array)));
         }

template<size_t _Bits>

bool bitset< _Bits >::none ( ) const

inlineprivate

         {   // test if no bits are set
         return (!any());
         }

template<size_t _Bits>

bitset< _Bits >::operator bool ( ) const

inline

             {   // return element
             return (_Pbitset->test(_Mypos));
             }

template<size_t _Bits>

bool bitset< _Bits >::operator!= ( const bitset< _Bits > & _Right ) const

inlineprivate

         {   // test for bitset inequality
         return (!(*this == _Right));
         }

template<size_t _Bits>

bitset& bitset< _Bits >::operator&= ( const bitset< _Bits > & _Right )

inlineprivate

         {   // AND in _Right
         for (ptrdiff_t _Wpos = _Words; 0 <= _Wpos; --_Wpos)
             _Array[_Wpos] &= _Right._Getword(_Wpos);
         return (*this);
         }

template<size_t _Bits>

bitset bitset< _Bits >::operator<< ( size_t _Pos ) const

inlineprivate

         {   // return bitset shifted left by _Pos
         return (bitset(*this) <<= _Pos);
         }

template<size_t _Bits>

bitset& bitset< _Bits >::operator<<= ( size_t _Pos )

inlineprivate

         {   // shift left by _Pos
         const ptrdiff_t _Wordshift = (ptrdiff_t)(_Pos / _Bitsperword);
         if (_Wordshift != 0)
             for (ptrdiff_t _Wpos = _Words; 0 <= _Wpos; --_Wpos)
                 _Array[_Wpos] = _Wordshift <= _Wpos // shift by words
                     ? _Array[_Wpos - _Wordshift] : (_Ty)0;
 
         if ((_Pos %= _Bitsperword) != 0)
             {   // 0 < _Pos < _Bitsperword, shift by bits
             for (ptrdiff_t _Wpos = _Words; 0 < _Wpos; --_Wpos)
                 _Array[_Wpos] = (_Ty)((_Array[_Wpos] << _Pos)
                     | (_Array[_Wpos - 1] >> (_Bitsperword - _Pos)));
             _Array[0] <<= _Pos;
             }
         _Trim();
         return (*this);
         }

template<size_t _Bits>

reference& bitset< _Bits >::operator= ( const reference & _Bitref )

inline

             {   // assign reference to element
             _Pbitset->set(_Mypos, bool(_Bitref));
             return (*this);
             }

template<size_t _Bits>

bool bitset< _Bits >::operator== ( const bitset< _Bits > & _Right ) const

inlineprivate

         {   // test for bitset equality
         for (ptrdiff_t _Wpos = _Words; 0 <= _Wpos; --_Wpos)
             if (_Array[_Wpos] != _Right._Getword(_Wpos))
                 return (false);
         return (true);
         }

template<size_t _Bits>

bitset bitset< _Bits >::operator>> ( size_t _Pos ) const

inlineprivate

         {   // return bitset shifted right by _Pos
         return (bitset(*this) >>= _Pos);
         }

template<size_t _Bits>

bitset& bitset< _Bits >::operator>>= ( size_t _Pos )

inlineprivate

         {   // shift right by _Pos, first by words then by bits
         const ptrdiff_t _Wordshift = (ptrdiff_t)(_Pos / _Bitsperword);
         if (_Wordshift != 0)
             for (ptrdiff_t _Wpos = 0; _Wpos <= _Words; ++_Wpos)
                 _Array[_Wpos] = _Wordshift <= _Words - _Wpos
                     ? _Array[_Wpos + _Wordshift] : (_Ty)0;
 
         if ((_Pos %= _Bitsperword) != 0)
             {   // 0 < _Pos < _Bitsperword, shift by bits
             for (ptrdiff_t _Wpos = 0; _Wpos < _Words; ++_Wpos)
                 _Array[_Wpos] = (_Ty)((_Array[_Wpos] >> _Pos)
                     | (_Array[_Wpos + 1] << (_Bitsperword - _Pos)));
             _Array[_Words] >>= _Pos;
             }
         return (*this);
         }

template<size_t _Bits>

constexpr bool bitset< _Bits >::operator[] ( size_t _Pos ) const

inlineprivate

         {   // subscript nonmutable sequence
  #if _ITERATOR_DEBUG_LEVEL == 0
         return (_Subscript(_Pos));
 
  #else /* _ITERATOR_DEBUG_LEVEL == 0 */
         return (_Bits <= _Pos
             ? (_Validate(_Pos), false)
             : _Subscript(_Pos));
  #endif /* _ITERATOR_DEBUG_LEVEL == 0 */
         }

template<size_t _Bits>

reference bitset< _Bits >::operator[] ( size_t _Pos )

inlineprivate

         {   // subscript mutable sequence
         _Validate(_Pos);
         return (reference(*this, _Pos));
         }

template<size_t _Bits>

bitset& bitset< _Bits >::operator^= ( const bitset< _Bits > & _Right )

inlineprivate

         {   // XOR in _Right
         for (ptrdiff_t _Wpos = _Words; 0 <= _Wpos; --_Wpos)
             _Array[_Wpos] ^= _Right._Getword(_Wpos);
         return (*this);
         }

template<size_t _Bits>

bitset& bitset< _Bits >::operator|= ( const bitset< _Bits > & _Right )

inlineprivate

         {   // OR in _Right
         for (ptrdiff_t _Wpos = _Words; 0 <= _Wpos; --_Wpos)
             _Array[_Wpos] |= _Right._Getword(_Wpos);
         return (*this);
         }

template<size_t _Bits>

bool bitset< _Bits >::operator~ ( ) const

inline

             {   // return complemented element
             return (!_Pbitset->test(_Mypos));
             }

template<size_t _Bits>

bitset bitset< _Bits >::operator~ ( ) const

inlineprivate

         {   // flip all bits
         return (bitset(*this).flip());
         }

template<size_t _Bits>

bitset< _Bits >::reference ( )

inlineprivate

             : _Pbitset(0), _Mypos(0)
             {   // default construct
             }

template<size_t _Bits>

bitset< _Bits >::reference	(	bitset< _Bits > &	_Bitset,
		size_t	_Pos
	)

inlineprivate

             : _Pbitset(&_Bitset), _Mypos(_Pos)
             {   // construct from bitset reference and position
             }

template<size_t _Bits>

bitset& bitset< _Bits >::reset ( )

inlineprivate

         {   // set all bits false
         _Tidy();
         return (*this);
         }

template<size_t _Bits>

bitset& bitset< _Bits >::reset ( size_t _Pos )

inlineprivate

         {   // set bit at _Pos to false
         return (set(_Pos, false));
         }

template<size_t _Bits>

bitset& bitset< _Bits >::set ( )

inlineprivate

         {   // set all bits true
         _Tidy((_Ty)~0);
         return (*this);
         }

template<size_t _Bits>

bitset& bitset< _Bits >::set	(	size_t	_Pos,
		bool	_Val = `true`
	)

inlineprivate

         {   // set bit at _Pos to _Val
         if (_Bits <= _Pos)
             _Xran();    // _Pos off end
         if (_Val)
             _Array[_Pos / _Bitsperword] |= (_Ty)1 << _Pos % _Bitsperword;
         else
             _Array[_Pos / _Bitsperword] &= ~((_Ty)1 << _Pos % _Bitsperword);
         return (*this);
         }

template<size_t _Bits>

constexpr size_t bitset< _Bits >::size ( ) const

inlineprivate

         {   // return size of bitset
         return (_Bits);
         }

template<size_t _Bits>

bool bitset< _Bits >::test ( size_t _Pos ) const

inlineprivate

         {   // test if bit at _Pos is set
         if (_Bits <= _Pos)
             _Xran();    // _Pos off end
         return (_Subscript(_Pos));
         }

template<size_t _Bits>

template<class _Elem = char, class _Tr = char_traits<_Elem>, class _Alloc = allocator<_Elem>>

basic_string<_Elem, _Tr, _Alloc> bitset< _Bits >::to_string	(	_Elem	_E0 = `(_Elem)'0'`,
		_Elem	_E1 = `(_Elem)'1'`
	)		const

inlineprivate

         {   // convert bitset to string
         basic_string<_Elem, _Tr, _Alloc> _Str;
         typename basic_string<_Elem, _Tr, _Alloc>::size_type _Pos;
         _Str.reserve(_Bits);
 
         for (_Pos = _Bits; 0 < _Pos; )
             if (test(--_Pos))
                 _Str += _E1;
             else
                 _Str += _E0;
         return (_Str);
         }

template<size_t _Bits>

_ULonglong bitset< _Bits >::to_ullong ( ) const

inlineprivate

         {   // convert bitset to unsigned long long
         static_assert(sizeof (_ULonglong) % sizeof (_Ty) == 0,
             "unsigned long long not multiple of _Ty");
 
         ptrdiff_t _Wpos = _Words;
         for (; (ptrdiff_t)(sizeof (_ULonglong) / sizeof (_Ty)) <= _Wpos;
             --_Wpos)
             if (_Array[_Wpos] != 0)
                 _Xoflo();   // fail if any high-order words are nonzero
 
         _ULonglong _Val = _Array[_Wpos];
         for (; 0 <= --_Wpos; )
             _Val = ((_Val << (_Bitsperword - 1)) << 1) | _Array[_Wpos];
         return (_Val);
         }

template<size_t _Bits>

unsigned long bitset< _Bits >::to_ulong ( ) const

inlineprivate

         {   // convert bitset to unsigned long
         _ULonglong _Val = to_ullong();
         unsigned long _Ans = (unsigned long)_Val;
         if (_Ans != _Val)
             _Xoflo();
         return (_Ans);
         }

Member Data Documentation

template<size_t _Bits>

_Ty bitset< _Bits >::_Array[_Words+1]

private

template<size_t _Bits>

constexpr _ULonglong bitset< _Bits >::_Mask = (1ULL << (_Need_mask ? _Bits : 0)) - 1ULL

staticprivate

template<size_t _Bits>

size_t bitset< _Bits >::_Mypos

private

template<size_t _Bits>

constexpr bool bitset< _Bits >::_Need_mask = _Bits < CHAR_BIT * sizeof (_ULonglong)

staticprivate

template<size_t _Bits>

bitset<_Bits>* bitset< _Bits >::_Pbitset

private

template<size_t _Bits>

return* bitset< _Bits >::this

The documentation for this class was generated from the following file:

VS2015/inc/bitset

Public Types

Public Member Functions

Public Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation