bitset< _Bits > Class Template Reference

Public Types
typedef _If< _Bits<=32, _Uint32t, unsigned long long >::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 (unsigned long long _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
unsigned long long	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 (unsigned long long)
static constexpr unsigned long long	_Mask = (1ULL << (_Need_mask ? _Bits : 0)) - 1ULL

Member Typedef Documentation

template<size_t _Bits>

typedef _If<_Bits <= 32, _Uint32t, unsigned long long>::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 ( unsigned long long  _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

        {   // no bits to trim, do nothing
        }

template<size_t _Bits>

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

inlinestaticprivate

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

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>

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

inlineprivate

        {   // convert bitset to unsigned long long
        static_assert(sizeof (unsigned long long) % sizeof (_Ty) == 0,
            "unsigned long long not multiple of _Ty");

        ptrdiff_t _Wpos = _Words;
        for (; (ptrdiff_t)(sizeof (unsigned long long) / sizeof (_Ty)) <= _Wpos;
            --_Wpos)
            if (_Array[_Wpos] != 0)
                _Xoflo();   // fail if any high-order words are nonzero

        unsigned long long _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
        unsigned long long _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 unsigned long long 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 (unsigned long long)

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:

• VS2017/inc/bitset