bitset File Reference

#include <string>
#include <iosfwd>

Classes
class	bitset< _Bits >
struct	hash< bitset< _Bits > >

Macros
#define	_BITSET_
#define	_BITSET_SIZE_TYPE   typename basic_string<_Elem, _Tr, _Alloc>::size_type

Functions
template<size_t _Bits>
bitset< _Bits >	operator& (const bitset< _Bits > &_Left, const bitset< _Bits > &_Right) _NOEXCEPT
template<size_t _Bits>
bitset< _Bits >	operator| (const bitset< _Bits > &_Left, const bitset< _Bits > &_Right) _NOEXCEPT
template<size_t _Bits>
bitset< _Bits >	operator^ (const bitset< _Bits > &_Left, const bitset< _Bits > &_Right) _NOEXCEPT
template<class _Elem , class _Tr , size_t _Bits>
basic_ostream< _Elem, _Tr > &	operator<< (basic_ostream< _Elem, _Tr > &_Ostr, const bitset< _Bits > &_Right)
template<class _Elem , class _Tr , size_t _Bits>
basic_istream< _Elem, _Tr > &	operator>> (basic_istream< _Elem, _Tr > &_Istr, bitset< _Bits > &_Right)

Macro Definition Documentation

#define _BITSET_

#define _BITSET_SIZE_TYPE   typename basic_string<_Elem, _Tr, _Alloc>::size_type

Function Documentation

template<size_t _Bits>

bitset<_Bits> operator& ( const bitset< _Bits > &  _Left, const bitset< _Bits > &  _Right  )

inline

        {   // return bitset _Left AND _Right
        bitset<_Bits> _Ans = _Left;
        return (_Ans &= _Right);
        }

template<class _Elem , class _Tr , size_t _Bits>

basic_ostream<_Elem, _Tr>& operator<< ( basic_ostream< _Elem, _Tr > &  _Ostr, const bitset< _Bits > &  _Right  )

inline

    {   // insert bitset as a string
    const ctype<_Elem>& _Ctype_fac = _USE(_Ostr.getloc(), ctype<_Elem>);
    const _Elem _E0 = _Ctype_fac.widen('0');
    const _Elem _E1 = _Ctype_fac.widen('1');

    return (_Ostr
        << _Right.template to_string<_Elem, _Tr, allocator<_Elem> >(
            _E0, _E1));
    }

template<class _Elem , class _Tr , size_t _Bits>

basic_istream<_Elem, _Tr>& operator>> ( basic_istream< _Elem, _Tr > &  _Istr, bitset< _Bits > &  _Right  )

inline

    {   // extract bitset as a string
    const ctype<_Elem>& _Ctype_fac = _USE(_Istr.getloc(), ctype<_Elem>);
    const _Elem _E0 = _Ctype_fac.widen('0');
    const _Elem _E1 = _Ctype_fac.widen('1');
    ios_base::iostate _State = ios_base::goodbit;
    bool _Changed = false;
    string _Str;
    const typename basic_istream<_Elem, _Tr>::sentry _Ok(_Istr);

    if (_Ok)
        {   // valid stream, extract elements
        _TRY_IO_BEGIN
        typename _Tr::int_type _Meta = _Istr.rdbuf()->sgetc();
        for (size_t _Count = _Right.size(); 0 < _Count;
            _Meta = _Istr.rdbuf()->snextc(), --_Count)
            {   // test _Meta
            _Elem _Char;
            if (_Tr::eq_int_type(_Tr::eof(), _Meta))
                {   // end of file, quit
                _State |= ios_base::eofbit;
                break;
                }
            else if ((_Char = _Tr::to_char_type(_Meta)) != _E0
                && _Char != _E1)
                break;  // invalid element
            else if (_Str.max_size() <= _Str.size())
                {   // no room in string, give up (unlikely)
                _State |= ios_base::failbit;
                break;
                }
            else
                {   // valid, append '0' or '1'
                if (_Char == _E1)
                    _Str.append(1, '1');
                else
                    _Str.append(1, '0');
                _Changed = true;
                }
            }
        _CATCH_IO_(_Istr)
        }

    if (!_Changed)
        _State |= ios_base::failbit;
    _Istr.setstate(_State);
    _Right = bitset<_Bits>(_Str);   // convert string and store
    return (_Istr);
    }

template<size_t _Bits>

bitset<_Bits> operator^ ( const bitset< _Bits > &  _Left, const bitset< _Bits > &  _Right  )

inline

        {   // return bitset _Left XOR _Right
        bitset<_Bits> _Ans = _Left;
        return (_Ans ^= _Right);
        }

template<size_t _Bits>

bitset<_Bits> operator| ( const bitset< _Bits > &  _Left, const bitset< _Bits > &  _Right  )

inline

        {   // return bitset _Left OR _Right
        bitset<_Bits> _Ans = _Left;
        return (_Ans |= _Right);
        }