自己写了一个c++ bitset，功能非常齐全！

关注

原创最新推荐文章于 2026-03-03 00:06:23 发布 5.1k 阅读 AI 写同款· GEO 优化 ›

[C++] 用bitset代替bool数组的性能测试以及bitset的基本使用文章目录bitset介绍使用¶头文件¶指定大小¶构造函数¶运算符¶成员函数¶应用¶算法样例题bitset与埃氏筛结合埃氏筛速度测试 bitset 介绍 std::bitset 是标准库中的一个存储 0/1 的大小不可变容器。严格来讲，它并不属于 STL。 bitset 并不属于 STL，而是一种标准库中的 “Special Container”。事实上，它作为一种容器，也并不满足 STL 容器的要求。说它是适配器，它也并不依赖于其它 STL 容器作为底层实现。——摘自《The C++ Standard L 阅读详情

c++ bitset用途很广，而理解它的最好方式莫过于自己写一个，重新造轮子还是非常有乐趣的，废话不多说了，贴代码。
首先是一些必要的函数，封装在名字空间mystd里面。

/*如果发现有bug，望高手批评指正！相互交流交流！
* 转载本文的注明一下出处，谢谢！
*/

#ifndef MYSTD_BIT_OPERATION_H
#define MYSTD_BIT_OPERATION_H
#include<cstddef>
#include<cassert>


#ifdef __cplusplus
namespace mystd{
	typedef std::size_t size_type;

     unsigned char get_true(size_type index) // 1 - 8
	{
		assert(index >= 1 && index <= 8);
		return (unsigned char)1 << (index - 1) ;
		// 得到形如00010000这样的数
	}
	 unsigned char get_false(size_type index)
	{
		assert(index >= 1 && index <= 8);
		return ~get_true(index);
		// 得到形如11101111这样的数
	}

	void set_false(unsigned char& val,size_type index) // index (1 - 8)
	{
		assert(index >= 1 && index <= 8);
		val &= get_false(index);
	}
	void set_true( unsigned char& val,size_type index) // index (1 - 8) 
	{
		assert(index >= 1 && index <= 8);
		val |= get_true(index);
	}

	void* set(void* ptr,size_type pos,bool val = true)
	{   //一般性的函数，处理数组中单个值的单个bit的设定
		assert(ptr != 0);
		unsigned char *pointer = (unsigned char*)ptr;
		size_type subpos = (pos + 7)/ 8 - 1; 
		size_type index = (pos + 7) % 8  + 1;
		if(val)
			set_true(pointer[subpos],index);
		else
			set_false(pointer[subpos],index);
		return ptr;
	}

	bool read(void *ptr,size_type pos) 
	{
		assert(ptr != 0);
		unsigned char *pointer = (unsigned char*)ptr;
		size_type subpos = (pos + 7)/ 8 - 1;  
		size_type index = (pos  + 7) % 8 + 1;
		unsigned char tmp_val = (pointer[subpos] >> (index - 1) ) & unsigned char(1) ;
		return tmp_val > 0;
	}

} // end of namespace mystd 
#endif // __cplusplus
#endif // MYSTD_BIT_OPERATION_H

下面进入正文，bitset封装在名字空间mystd里面，注释说明的还算详细，贴代码！

文件名 bitset.h

/*如果发现有bug，望高手批评指正！相互交流交流！
* 转载本文的注明一下出处，谢谢！
*/

#ifndef MYSTD_BITSET_TEST_H
#define MYSTD_BITSET_TEST_H
#include"bit_operation.h"  //read ,set函数
#include<cassert>  // assert
#include<cstddef>   // std::size_t
#include<string>   // std::string 
#include<cstring>   // std::memset
#include<exception>   
#include<iostream>    

#ifdef __cplusplus

namespace mystd{
	class  invalid_argument_1{};

	template<std::size_t N>
	class bitset{
	private:
		typedef bitset self;
		typedef std::size_t size_type;
		typedef unsigned long ULONG;
		typedef unsigned long long ULLONG;
		typedef unsigned char UCHAR;
	private:
		class ref{  //写一个辅助类，因为c++无法对单个的位进行索引，
	    // c++之父在<<c++程序设计语言>>（十周年纪念版436页）中有提到这一技术，但是只有接口，没有实现，
		// 这个是我的一个实现，当然接口不太一样，我有所改变
		private:
			typedef std::size_t size_type;
			typedef ref self;
			UCHAR *head;
			size_type position;
		public:
			ref(UCHAR* tmp_ptr,size_type pos):head(tmp_ptr),position(pos)
			{
			}
		public:
			self& operator = (const self& tmp)
			{//mystd::set的pos以1开始计数,因此加1,以下都是如此
				mystd::set(head,position+1,mystd::read(tmp.head,tmp.position+1));
				return *this;
			}
			self& operator = (const bool& tmp)
			{
				assert(head != 0);
				mystd::set(head,position + 1,tmp);
				return *this;
			}
			bool operator == (const bool& tmp) const 
			{
				assert(head != 0);
				return mystd::read(head,position + 1) == tmp;
			}
			bool operator != (const bool& tmp) const
			{
			    assert(head != 0);
				return !(*this == tmp);
			}
			bool operator == (const self& tmp) const 
			{
				assert(head != 0);
				return mystd::read(head,position + 1) == 
					mystd::read(tmp.head,tmp.position + 1);
			}
			bool operator != (const self& tmp) const 
			{
              return !(*this == tmp);
			}
			
			friend std::ostream& operator << (std::ostream& os,const self& tmp)
			{
				return os << mystd::read(const_cast<UCHAR*>(tmp.head),tmp.position + 1);
			}
			friend std::istream& operator >> (std::istream& is,self& tmp)
			{ // 标准库无此功能,感觉应该加上，个人见解，呵呵！
				bool tmp_val = false;
				is>>tmp_val;
				mystd::set(tmp.head,tmp.position + 1,tmp_val);
				return is;
			}
		};

	private:
		typedef ref reference;
		typedef const ref const_reference;
		static const size_type SIZE = N;
		UCHAR *head;
	private:   //内部使用的一些函数
		bool read(void *ptr,size_type pos) const   // 从0开始
		{ // mystd里的read以1开始计数，在这里转换下,以下同理可得
			return mystd::read(ptr,pos+1);
		}
		void* set(void* ptr,size_type pos,bool val = true) const  // 从0开始
		{ //从逻辑上讲，不应该用const，为了通用性，加了个const
		  // 也可以另外写一个非const版本
			return mystd::set(ptr,pos+1,val);
		}
		size_type get_pos(size_type pos) const   // 从0开始
		{ // 举例说明，低位到高位假如有10位1000 0001 11 则最后一位getpos的结果为1,
			// 是第二个字节，getsub则是1
			return pos / 8;
		}
		size_type get_sub(size_type pos) const   // 从0开始
		{  // 
			return pos % 8;
		}
		// 计算有效位数,由低位到高位，如11010000有效位为4位
		size_type get_num_count() const 
		{
			size_type m_count = 0;
			for(size_type i = size(); i >= 1; )
				if(test(--i))
					break;
				else
					++m_count;
			return size() - m_count;
		}
		void zero_last() //将最后剩余位清零
		{  //如，有4位1101,但是分配的是一个字节，最后的4位无用，清零
			size_type cur_pos = get_pos(size());
			size_type cur_sub = get_sub(size());
			++cur_sub;
			for(size_type i = cur_sub; i < 8; ++i)
				set(&head[cur_pos],i,false);
		}
		void fill(size_type first,size_type last,bool val = false) 
		{  // 对区间[first,last)内的位进行填充
			assert(first >= 0 && last <= size());
			for(size_type i = first; i < last; ++i)
				set(i,val);  // 成员函数
		}
		void copy_left(size_type des,size_type beg,size_type end)
		{  // 区间[beg,end);
			assert(des >= 0 && des <= beg);
			if(des == beg)  // 移动0位的情况
				return ;
			while(beg != end)
				set(des++,test(beg++));
		}
		void copy_right(size_type des,size_type beg,size_type end)
		{  // 向后复制,des为末端位置加 1
		   assert(des >= end && des <= size());
		   if(end == size())   // 移动0位的情况
			   return ;
		   while(end != beg)
			   set(--des,test(--end));
		}
	public:
		bitset()  
			try:head(0)   
		{  //计算分配的字节数，如SIZE 为10则分配2个字节就可以了，剩余6位。（16-10）
			// 以下同理可得
			head = new UCHAR[get_pos(size()) + 1];
			std::memset(head,0,get_pos(size()) + 1); // 
		}
		catch(...)
		{
#ifdef _DEBUG
    std::cerr<<"out of memory"<<std::endl;
#endif
		}
		explicit bitset(ULONG val)    // unsigned long 版本
			try:head(0)
		{
			head = new UCHAR[get_pos(size()) + 1];
			std::memset(head,0,get_pos(size()) + 1); // 
			for(size_type i = 0; i < size() && i < sizeof(ULONG) * 8; ++i)
				set(i,read(&val,i));
		}
		catch(...)
		{
#ifdef _DEBUG
    std::cerr<<"out of memory"<<std::endl;
#endif
		}
		explicit bitset(const std::string& str,size_type pos = 0,size_type n = std::string::npos)
			try:head(0)
		{
			
			head = new UCHAR[get_pos(size()) + 1];
			std::memset(head,0,get_pos(size()) + 1); // 
			assert(n == std::string::npos || pos + n < str.size());
			if(pos + n > str.size())
				n = str.size() - pos;
			for(size_type i = 0,j = pos + n; i < size() && j >= pos + 1; )
			{
				assert(str[j-1] == '0' || str[j-1] == '1');
#ifdef NDEBUG
				if(str[j-1] != '0' && str[j-1] != '1')
					throw mystd::invalid_argument_1();  //非法参数，抛出异常
#endif
				set(head,i++,str[--j] == '1');
			}
		}
		catch(...)
		{
#ifdef _DEBUG
    std::cerr<<"out of memory"<<std::endl;
#endif
		}
		 //复制构造函数
		 bitset(const self& temp):head(0)
		{
			head = new UCHAR[get_pos(size()) + 1];
			std::memcpy(head,temp.head,get_pos(size()) + 1);
		}
		self& operator = (const self& temp)  //复制赋值
		{    // 直接覆盖，这里不用先释放资源，因为类型一致，SIZE一样
			if(this == &temp)
				return *this;
			std::memcpy(head,temp.head,get_pos(size()) + 1);
			return *this;
		}
		~bitset()
		{
			delete [] head;
		}
	public:
		const_reference operator [] (size_type pos) const 
		{
			assert(pos < size());
	        return reference(head,pos);
		}
	
		reference operator [] (size_type pos)
		{
			assert(pos < size());
			return reference(head,pos);
		}

		size_type size() const 
		{
			return SIZE;
		}

		size_type count() const 
		{
			size_type m_count = 0;
			for(size_type i = 0; i < size(); ++i)
			{
			size_type cur_pos = get_pos(i);
			size_type cur_sub = get_sub(i);
			if(read(&head[cur_pos],cur_sub))
				++m_count;
			}
			return m_count;
		}

       self& set()
	   {
		   std::memset(head,0xFF,get_pos(size()) + 1);
		   // 将剩余的位清零
		   zero_last();
		   return *this;
	   }
       self& set(size_type pos, bool val = true)
	   {
		   assert(pos < size());
		   size_type cur_pos = get_pos(pos);
		   size_type cur_sub = get_sub(pos);
		   set(&head[cur_pos],cur_sub,val);
		   return *this;
	   }

	   bool any() const 
	   {
	  for(size_type i = 0; i <= get_pos(size()); ++i)
		  if(head[i])
			  return true;
	  return false;
	   }
	   bool none() const 
	   {
		   for(size_type i = 0; i <= get_pos(size()); ++i)
			   if(head[i])
				   return false;
		   return true;
	   }
	   self& reset()
	   {
		 std::memset(head,0,get_pos(SIZE) + 1);
		 return *this;
	   }
	   self& reset(size_type pos)
	   {
		   assert(pos < size());
		   size_type cur_pos = get_pos(pos);
		   size_type cur_sub = get_sub(pos);
		   set(&head[cur_pos],cur_sub,false);
		   return *this;
	   }
	   bool test(size_t pos) const
	   {
		   assert(pos < size());
           size_type cur_pos = get_pos(pos);
		   size_type cur_sub = get_sub(pos);
		   return read(&head[cur_pos],cur_sub);
	   }

	   self& flip()
	   {
		   size_type pos = get_pos(size());
		   for(size_type i = 0; i <= pos; ++i)
			   head[i] = ~head[i];
		   zero_last();
		   return *this;
	   }
	   self& filp(size_type pos)
	   {
		   assert(pos < size());
		   if(test(pos))
			   set(pos,false);
		   else
			   set(pos,true);
		   return *this;
	   }
	   std::string to_string() const 
	   {
		   std::string str(size(),'0');   // 自动增长效率低，所以直接初始化
		   for(size_type i = size(),j = 0; i >= 1; )
			   if(test(--i))
				   str[j++] = '1';
			   else
				   ++j; // 不做无用功，直接跳过，不用复制了
		   return str;
	   }
	   ULONG to_ulong() const 
	   { 
		   size_type num_count = get_num_count();
		   assert(num_count <= sizeof(ULONG) * 8);
#ifdef NDEBUG
		   if(num_count > sizeof(ULONG) * 8) 
			   throw std::overflow_error("overflow error,please check it");
#endif
		   if(size() == sizeof(ULONG) * 8 || num_count == sizeof(ULONG) * 8)
		       return *(ULONG*)head;
		   ULONG tmp_val = 0;
		   for(size_type i = 0; i < num_count; ++i)
			   set(&tmp_val,i,test(i));
		   return tmp_val;
	   }
	   ULLONG to_ullong() const   // c++11 功能
	   {
		   size_type num_count = get_num_count();
		   assert(num_count <= sizeof(ULLONG) * 8);
#ifdef NDEBUG
		     if(num_count > sizeof(ULLONG) * 8) 
			   throw std::overflow_error("overflow error,please check it");
#endif
		   if(size() == sizeof(ULLONG)* 8 || num_count == sizeof(ULLONG) * 8)
		       return *(ULLONG*)head;
		   if(num_count <= sizeof(ULONG) * 8) 
			   return to_ulong();
		   ULLONG tmp_val = 0;
		   for(size_type i = 0; i < num_count; ++i)
			   set(&tmp_val,i,test(i));
		   return tmp_val;
	   }
	   //下面是一些位操作符的重载
	   self& operator &= (const self& obj)
	   {
		  size_type position = get_pos(size());
		  for(size_type i = 0; i <= position ; ++i)
			  head[i] &= obj.head[i];
		  return *this;
	   }
	   self& operator |= (const self& obj)
	   {
		  size_type position = get_pos(size());
		  for(size_type i = 0; i <= position; ++i)
			  head[i] |= obj.head[i];
		  return *this;
	   }
	   self& operator ^= (const self& obj)
	   {
		  size_type position = get_pos(size());
		  for(size_type i = 0; i <= position; ++i)
			  head[i] ^= obj.head[i];
		  return *this;
	   }
	   self operator | (const self& obj) const 
	   {
		   self temp(*this);
		   temp |= obj;
		   return temp;
	   }
	   self operator & (const self& obj) const 
	   {
		   self temp(*this);
		   temp &= obj;
		   return temp;
	   }
	   self operator ^ (const self& obj) const
	   {
		   self temp(*this);
		   temp ^= obj;
		   return temp;
	   }
	   self operator ~ () const 
	   {
		   self temp(*this);
		   temp.flip();
		   return temp;
	   }
	   self& operator <<= (size_type n)
	   {
		   if(n == 0)
			   return *this;
		   if(n >= size())
			  std::memset(head,0,get_pos(size()) + 1);
		   //相对向右复制覆盖
		   else
		   {
		   copy_right(size(),0,size()-n);  
		   fill(0,n,false); // 空出的位置填充0
		   }
		   return *this;
	   }
	  self& operator >>= (size_type n)
	   {
		   if(n == 0) 
			   return *this;
		   if(n >= size())
			   std::memset(head,0,get_pos(size()) + 1);
		   else
		   {
		   copy_left(0,n,size());
		   fill(size()-n,size(),false);
		   }
		   return *this;
	   }
	  self operator << (size_type n) const 
	  {
		  self temp(*this);
		  temp <<= n;  // 转调operator <<= 
		  return temp;
	  }
	  self operator >> (size_type n) const 
	  {
		  self temp(*this);
		  temp >>= n;
		  return temp;
	  }
	  bool operator == (const self& obj) const 
	  {
		  size_type pos = get_pos(size());
		  for(size_type i = 0; i <= pos; ++i)
			  if(head[i] != obj.head[i])
				  return false;
		  return true;
	  }
	  bool operator != (const self& obj) const 
	  {
		  return !(*this == obj);
	  }
	   friend std::ostream& operator << (std::ostream& os,const self& obj)
	   {
		   for(size_type i = obj.size(); i >0; )
			   os<<obj.test(--i);
		   return os;
	   }
	};

} // end of namespace mystd 
#endif //__cplusplus
#endif //MYSTD_BITSET_TEST_H

下面是一个小测试程序，并与标准库的运行结果进行比对！看代码！

#include<iostream>
#include<fstream>
#include<bitset> // 标准库
#include"bitset.h"  // mystd::bitset
#define STD mystd   // 改为mystd运行自己写的bitset版本


using std::cout;
using std::endl;

int main()
{  // 为了方便和标准库比对，将结果写入文件，test.txt在当前目录
	std::fstream out("test.txt",std::ios_base::out | std::ios_base::app);
	if(!out)
	{
		std::cerr<<"文件打开失败！"<<endl;
		exit(1);
	}
	out<<"********************mystd::bitset执行结果!********************"<<endl;
	const int mn =64;
	STD::bitset<mn> test_1;  
	STD::bitset<mn> super_test(test_1);  // 验证复制构造函数
	//下面的代码随便写了，主要测试和标准库的结果是否一致
	test_1.set(20);
	test_1[50] = 1;
	out<<(test_1 ^ super_test)<<endl;
	out<<(test_1 & super_test)<<endl;
	out<<(test_1 | super_test)<<endl;
	super_test.set(10);
	super_test.set(50,0);
	super_test.reset();
	super_test.flip();
	super_test[60] = 1;
	super_test[20] = 0;
	out<<super_test<<endl;
	out<<super_test.to_string()<<endl;
	super_test[49] = 1;
	out<<super_test.to_ullong()<<endl;
	super_test[63] = 1;
	//out<<super_test.to_ulong()<<endl;
	if(super_test.any())
		out<<"存在一个bit为1"<<endl;
	if(super_test.none())
		out<<"不存在一个bit为1"<<endl;
	super_test.reset();
	if(super_test.none())
		out<<"不存在一个bit为1"<<endl;
	super_test[50] = 1;
	super_test[36] = 1;
	super_test <<= 20;
	super_test >>= 5;
	test_1 = super_test;
	if(test_1 == super_test)
		out<<"相等"<<endl;
	else
		out<<"不等"<<endl;

	out<<STD::bitset<100>("1100011")<<endl;
	out<<(STD::bitset<53>(102545) << 20)<<endl;
	system("pause");
	return 0;
}

最终的运行结果，截图