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;
}