C++中bitset的實現（引用類的使用）

    #include <iostream>


#include <string.h>  
#define CHAR_BIT 8  
using namespace std;  

template<size_t _N>  
class bitset  
{  
    typedef unsigned long _Ty;   
    friend ostream & operator << (ostream &_O,const bitset<_N> &_R)  
    {  
        for(size_t _P=_N;_P>0;)  
            _O<<(_R.test(--_P)?'1':'0');  
        return _O;  
    }  
    public:  
    class reference  
    {  
        public:  
        friend class bitset<_N>;  
        reference &operator=(bool _X)  
        {  
            _Pbs->set(_Off,_X);  
            return *this;  
        }  
        reference& operator=(const reference &_Bs)  
        {  
            _Pbs=_Bs._Pbs;  
            _Off=_Bs._Off;  
              return *this;  
        }  
        operator bool()const  
        {     
            return _Pbs->test(_Off-1);  
        }         
        bool operator~()const  
        {  
            _Pbs->flip(_Off);  
        }  
        bool operator &(const reference &_Bs)  
        {  
            return (_Pbs->test(_Off-1)&_Bs._Pbs->test(_Bs._Off-1));  
        }  
        private:  
        reference(bitset<_N> *_X,size_t _P):_Pbs(_X),_Off(_P){}  
        bitset<_N> *_Pbs;  
        size_t _Off;  
    };  


bool at(size_t _P)const  
 {  
  return test(_P);  
 }  

bool operator[](size_t _P)const  
    {  
        return test(_P);  
    }  
reference operator[](size_t _P)  
    {  
        return reference(this,_P);  
    }  
    bitset()  
    {  
        _Tidy();  
    }  
    bitset(const string &_S)  
    {     
        _Tidy();  
        int _I=0;  
        while(_S[_I]!='\0')  
        {  
            int _D = _S[_I]=='1'?1:0;  
            _I++;  
            set(_I,_D);  
        }  
    }  
    bitset(int x)  
    {  
        _Tidy();  
        _A[0]|=(_Ty)x;  
    }  
    bitset(const string &_S,int _X)  
    {  
        _Tidy();  
        int _I=0;  
        while(_S[_I]!='\0')  
        {  
            int _D = _S[_I]=='1'?1:0;  
            _I++;  
            set(_I,_D);  
        }  
        set(_X,1);  
    }  
  bitset<_N>& set()  
    {  
                _Tidy(~(_Ty)0);  
                return *this;  
    }  
    bitset<_N>& set(size_t _P, bool _X = true)  
    {  
        if(_X)  
     _A[_P/_Nb] |= ((_Ty)0x1<<(_P%(_N+1))-1);       
        else  
        {     
            _A[_P/_Nb] &= ~((_Ty)0x1<<(_P%(_N+1))-1);  
        }  
    return *this;  
    }  
    bitset<_N>& reset()  
    {  
            _Tidy();  
            return *this;  
    }  
    bitset<_N>& reset(size_t _P)  
    {     
        set(_P,0);  
        return *this;  
    }  
    bitset<_N>& flip()  
    {  
        for(int _I=0;_I<=_Nw;_I++)  
        {  
            _A[_I]^=(~(_Ty)0x0);  
        }  
        _Trim();          
    }  
    bitset<_N>& flip(size_t _P)  
    {  
        _A[_P/_Nb] ^= ((_Ty)0x1<<(_P%(_Nb+1)-1));  
        return *this;  
    }  
    size_t size()const  
    {  
        return _N;  
    }  
    size_t count()const  
    {  
     size_t _V=0;  
        for(int _I=_Nw;_I>=0;--_I)  
            for(_Ty _X=_A[_I];_X!=0;_X>>=4)  
            _V+="\0\1\1\2\1\2\2\3\1\2\2\3\2\3\3\4"[0xff&_X];  
        return _V;  
    }  
    bitset<_N> operator~()  
    {  
        for(int _I=0;_I<=_Nw;++_I)  
            _A[_I]=~_A[_I];  
        _Trim();  
        return *this;  
    }  
    unsigned long to_ulong() const  
    {  
        enum{_Assertion=1/(sizeof(unsigned long)%sizeof(_Ty)==0)};  
        int _I = _Nw;  
        for(;sizeof(unsigned long)/sizeof(_Ty)<=_I;--_I)  
                if(_A[_I]!=0)  
                    break;  
        unsigned long _V=_A[_I];  
        for(;0<=--_I;)  
            _V=_V<<_Nb|_A[_I];  
        return (_V);  
    }  
    string to_string()const  
    {  
        string _S;  
        for(int _I=0;_I<=_Nw;_I++)  
        {     
            for(int _X=_A[_I];_X!=0;)  
                {  
                _S+=((_X&((_Ty)0x1))==1?"1":"0");  
                _X>>=1;  
                }  
        }  
        return _S;  
    }  
    bool any()const  
    {  
        for(int _I=0;_I<=_Nw;++_I)  
            if(_A[_I]!=0)  
                return true;  
        else    return false;     
    }  
    bool none()const  
    {  
        return !any();  
    }  
    bitset<_N>& operator&=(const bitset<_N> &_R)  
    {  
            for(int _I=0;_I<=_Nw;_I++)  
                    _A[_I]&=_R._A[_I];  
            return *this;  
    }  
    bitset<_N>& operator|=(const bitset<_N> &_R)  
    {  
            for(int _I=0;_I<=_Nw;_I++)  
                    _A[_I]|=_R._A[_I];  
            return *this;  
    }  
    bitset<_N>& operator^=(const bitset<_N> &_R)  
    {  
            for(int _I=0;_I<=_Nw;_I++)  
                _A[_I]^=_R._A[_I];  
            return *this;  
    }  
    friend bitset<_N> operator&(const bitset<_N> &_L, const bitset<_N> &_R)  
    {  
        return (bitset<_N>(_L)&=_R);  
    }  
    friend bitset<_N> operator|(const bitset<_N> &_L, const bitset<_N> &_R)  
    {  
        return (bitset<_N>(_L)|=_R);  
    }  
    friend bitset<_N> operator^(const bitset<_N> &_L, const bitset<_N> &_R)  
    {  
        return (bitset<_N>(_L)^=_R);  
    }  
    bitset<_N>& operator<<=(size_t _P)  
    {  
    int _D = _P/_Nb;  
    if(_D!=0)  
    {  
    int _I;  
        for( _I=_Nw;_I>0;_I--)     
              {  
                _A[_I] = _D<=_I?_A[_I-_D]:0;  
                }  
            for(int _J=0;_J<_D-1;_J++)  
                _A[_J] = 0;  
    }  
    if(_P%_Nb!=0)  
    {  
        int _I = _Nw;  
        for(;_I>0;--_I)  
        {  
            _A[_I]=(_A[_I]<<(_P%_Nb))|(_A[_I-1]>>(_Nb-_P%_Nb));  
        }  
    }  
        _A[0]<<=(_P%_Nb);  
        _Trim();  
        return *this;  
    }  
    bitset<_N>& operator>>=(size_t _P)  
    {  
        int _D = _P/_Nb;  
        if(_D!=0)  
        {  
            int _I;  
            for(_I=0;_I<=_Nw;_I++)  
            {  
                _A[_I] = _I+_D<=_Nw?_A[_I+_D]:0;  
            }  
            for(int _J=0;_J<_D;_J++)  
                _A[_Nw-_J]=0;  
        }  
        if(_P%_Nb!=0)  
        {     
            int _I = 0;  
            for(;_I<_Nw;++_I)  
            {     
                _A[_I]=(_A[_I]>>(_P%_Nb))|(_A[_I+1]<<(_Nb-_P%_Nb));  
            }  
        }  
        _A[_Nw]>>=(_P%_Nb);  
        _Trim();  
        return *this;  
    }  
    friend bitset<_N> operator<<(const bitset<_N> &_L, size_t _P)  
    {  
        return bitset<_N>(_L)<<=_P;  
    }  
    friend bitset<_N> operator>>(const bitset<_N> &_L,size_t _P)  
    {  
        return bitset<_N>(_L)>>=_P;  
    }  
    private:  
    bool test(size_t _P)const  
    {  
        return (((_A[_P/_Nb]) & (0x1<<(_P%_Nb)))!=0);  
    }  
    void _Tidy(_Ty _X=0)  
    {  
        for(int _I=_Nw;_I>=0;--_I)  
            _A[_I]=_X;  
         if(_X!=0)  
                _Trim();  
    }     
    void _Trim()  
    {  
        if(_N%_Nb!=0)  
            _A[_Nw]&=(((_Ty)0x1<<_N%_Nb)-1);  
    }  
    enum  
    {  
        _Nb=CHAR_BIT*sizeof(_Ty),  
        _Nw = _N==0?0:(_N-1)/_Nb,  
    };  
    _Ty _A[_Nw+1];  
};  
int main()  
{     
    bitset<10> bt1;  
    bt1[2]=1;  
    bitset<10> bt2;  
    bt2[2]=1;  
    cout<<(bt1[2]&bt2[2])<<endl;  
    return 0;  
}  </pre>