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

最新推荐文章于 2024-06-10 22:48:34 发布
最新推荐文章于 2024-06-10 22:48:34 发布
阅读量4.7k 收藏 4
点赞数 4
分类专栏： c++ 文章标签： c++ bitset 语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/focusing_on_cpp/article/details/45972981
版权

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

最终的运行结果，截图


 
为了方便和标准库进行比对，将于运行结果写入文件test.txt 

 

将上面代码的宏定义改一下，改为#define STD std 运行标准库版本，
 

看运行结果。
 

可以看到，运行结果完全一样。
 

如果大家有发现bug，希望不吝赐教！
 

谢谢！ 本文原创，转载的注明一下出处，谢谢！
 


 
 


 
 


 

                

        

        

    




    

      

        

            

              
                
                  爱读庄子的码农
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    4
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    4
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  5
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
C++基础之bitset

				
			

			

				

					itlilyer的博客
				

				

					07-21
					
					4008
					
				

			

		

		

			
				
类模板std::bitset
template <size_t N> class bitset;
头文件
#include <bitset>
说明
一个bitset中保存了一些bit(字节， 只能取两个值的元素：0或1，真或假 …)
bitset模拟了一个bool类型的数组，但是优化了内存空间：总的来说，每个元素值占用一个bit（比大多数系统中最小的元素char小了8倍）
每个位置的都可以独立的访问：例如，给定一个bitset命名为foo，foo[3]访问的就是第四个元素，就像通常数

			
		

	



                

              
                



	

		

			

				
					
C/C++中的memcpy函数的用法

					
热门推荐

				
			

			

				

					行走在消失中Jack
				

				

					09-20
					
					5万+
					
				

			

		

		

			
				
C/C++中的memcpy函数的用法
本文主要记录memcpy函数的用法，便于记住函数的过程。
编译环境
codeblock平台
功能
memcpy指的是c和c++使用的内存拷贝函数，memcpy函数的功能是从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中
头文件
所在头文件 &amp;lt;string.h&amp;gt;或&amp;lt; cstring &amp;gt;
函数原型
...

			
		

	



                


  
              

                


	

		

			

				
					
用BitSet创建一个01流的二进制文件

				
			

			

				

					倦鸟归时
				

				

					02-22
					
					1354
					
				

			

		

		

			
				
bitset bufferzero;
  bitset bufferone;
        int a=-1; int b=-1;
  for(int i=0;i
  {
    bufferzero[i]=0;
    bufferone[i]=1;
  } 
  //memset(bufferzero,0,1);
  //memset(bufferone,1,1);

			
		

	





	

		

			

				
					
C++——bitset

				
			

			

				

					JAN6055的博客
				

				

					03-17
					
					1万+
					
				

			

		

		

			
				
bitset——简单又方便的位运算工具

			
		

	



		

			
		



	

		

			

				
					
c++手写的bitset

					
最新发布

				
			

			

				

					qq_34179431的博客
				

				

					06-10
					
					305
					
				

			

		

		

			
				
支持stl bitset 类似的api。

			
		

	





	

		

			

				
					
C和C++中的bitset

				
			

			

				

					lzg_na的博客
				

				

					10-29
					
					1374
					
				

			

		

		

			
				
C/C++中没有bool类型，使用整形值表示bool类型占内存较多。C++中推出了bitset类库来，可以使用一个bit位来表示一个数据的bool类型，本文将有所介绍。另外在C语言中借助字符数组或整形值数组，同样可自己表示出bitset的机制。//声明一个长度为4bit的 bitset,默认每一位为 0. bitset < 8 > b(12);

			
		

	





	

		

			

				
					
2022-05-17 C++读入二进制文件并输出二进制文件

				
			

			

				

					老林的博客
				

				

					05-17
					
					2845
					
				

			

		

		

			
				
C++有各种奇怪的骚操作，今天说说其中一种。
最近看到个奇怪的需求：c++如何读入二进制文件,然后输出，意思是二进制读取，不进行任何转化，输出二进制。
从理论上讲，所有数据都是二进制的，但是很少人会将其展现出来，因为看不懂。但并不意味着这种操作毫无道理。
我们说的字符，数字，说到底不过是0101的组合，只是在于解释系统的不同，产生了不同分类。
刚学编程那会，看见有人用char代替int进行数据的计算和存储，觉得好奇怪，后来才明白，不过是0-255的数字，用int是8字节，废空间。
说回来，所有都是二进制，而

			
		

	





	

		

			

				
					
[C++] 用bitset代替bool数组的性能测试以及bitset的基本使用

				
			

			

				

					CppYyds的博客
				

				

					02-22
					
					3039
					
				

			

		

		

			
				
文章目录bitset介绍使用¶头文件¶指定大小¶构造函数¶运算符¶成员函数¶应用¶算法样例题bitset与埃氏筛结合埃氏筛速度测试
bitset
介绍
std::bitset 是标准库中的一个存储 0/1 的大小不可变容器。严格来讲，它并不属于 STL。

bitset 并不属于 STL，而是一种标准库中的 “Special Container”。事实上，它作为一种容器，也并不满足 STL 容器的要求。说它是适配器，它也并不依赖于其它 STL 容器作为底层实现。——摘自《The C++ Standard L

			
		

	





	

		

			

				
					
“Assertion `index ＞= -sizes[i] && index ＜ sizes[i] && “index out of bounds“` failed.” 解决方法

				
			

			

				

					不学无术的小镇做题家
				

				

					03-12
					
					4294
					
				

			

		

		

			
				
最近在使用Pytorch训练时报错，出现了以下信息：
Assertion `index >= -sizes[i] && index < sizes[i] && "index out of bounds

device-side assert triggered

可以判断时数组下标越界导致的，但是由于把数据加载到cuda里面，导致报错信息并不能帮助我们准确地定位错误位置，这时候，只需要将*.cuda()或者.*to(device)去掉，将模型放在cpu训练，就能看

			
		

	





	

		

			

				
					
STL中便捷的bitset

				
			

			

				

					浮白
				

				

					09-24
					
					3814
					
				

			

		

		

			
				
有些程序要处理二进制位的有序集，每个位可能包含的是0（关）或1（开）的值。位是用来保存一组项或条件的yes/no信息（有时也称标志）的简洁方法。标准库提供了bitset类使得处理位集合更容易一些。要使用bitset类就必须要包含相关的头文件。在本书提供的例子中，假设都使用了std::bitset的using声明：



			
		

	





	

		

			

				
					
[压位 手写bitset] BZOJ 2628 JZPSTR

				
			

			

				

					雯舞
				

				

					03-19
					
					2062
					
				

			

		

		

			
				
Hillan说 怎么暴力怎么写  
然后我们就每个数码用个bitset存一下就好了 
因为bitset太难操作 自己手写一个 
详见代码#include<cstdio>
#include<cstdlib>
#include<algorithm>
using namespace std;
typedef unsigned long long ull;inline char nc(){
  static

			
		

	





	

		

			

				
					
c++ bitset实现

				
			

			

				

					07-24
				

			

		

		

			
				
自己实现的bitset数据结构，在vs2005下编译通过。有测试成素。

			
		

	





	

		

			

				
					
C++:  模拟实现类bitset

				
			

			

				

					linwh8的博客
				

				

					03-17
					
					2750
					
				

			

		

		

			
				
C++:  模拟实现类bitset标签： C++ bitset 位运算by 小威威1.bitset简介bitset能实现对数字的位的操作，同时也能通过类似于数组的下标来访问各个位的数值，以执行相应的操作。模拟bitset就是用一个普通的数组来存储数据以达到模拟的目的。先声明一下，本篇文章并不是讲述标准库中bitset这个类的用法，而是去讲述如何实现一个模拟bitset的类。众所周知，int类型在64

			
		

	





	

		

			

				
					
C++ bitset 用法详解

				
			

			

				

					繁凡さん的博客
				

				

					04-16
					
					4081
					
				

			

		

		

			
				
C++的 bitset 在 bitset 头文件中，它是一种类似数组的结构，它的每一个元素只能是０或１，每个元素仅用１bit空间。
一般来说bitset会让你的算法复杂度 /32
下面是具体用法
构造函数
bitset常用构造函数有四种，如下
bitset<4> bitset1;　　//无参构造，长度为４，默认每一位为０

bitset<8> bitset2(12);　　/...

			
		

	





	

		

			

				
					
造轮子写bitset【STL的bitset很好了……  自己造的轮子虽然更快，但是不实在】

				
			

			

				

					ACMer不要报考高校代码为13627的移通学院！
				

				

					08-16
					
					817
					
				

			

		

		

			
				
结论：
ACM比赛要bitset还是直接用STL






发现： 左移1e7次，STL的bitset要用0.7~0.8秒左右！
而一个long long / int 只要0.06秒左右


于是准备自己写一个bitset


然后……同样的操作，在inline后，0.48秒上下浮动。可以比STL快一倍，但是依然常数巨大。


只造了一小部分做实验，希望有菊苣

			
		

	





	

		

			

				
					
bitset

				
			

			

				

					zhc_24的博客
				

				

					12-29
					
					341
					
				

			

		

		

			
				
写在前面：LeetCode刷着题，遇到一个黑科技bitset，之前没有遇到过。bitset存储位（元素只有两个可能的值：0或1，true或false，…）。 
这个类模拟一个布尔元素的数组，但是为空间分配进行了优化：通常，每个元素只占用一个位（在大多数系统上，它比最小的元素类型char少八倍）。 
每个位的位置可以单独访问：例如，对于一个名为foo的给定位集，表达式foo [3]访问其第四个位，就像

			
		

	





	

		

			

				
					
bitset 用法整理

				
			

			

				

					eecrazy的专栏
				

				

					08-30
					
					2万+
					
				

			

		

		

			
				
在项目中需要使用到10进制48位的数字按二进制由高到低解释，然后按每一位是0还是1来判断报警或错误状态。

所以，在Linux中的C++下需要用到二进制转换以及按位解析。收集到了一些资料，自己保存一下啊。

 

如下：

bitset 用法整理
构造函数
bitset b;
b有n位，每位都为0.参数n可以为一个表达式.
如bitset b0;则"b0"为"00000";

			
		

	





	

		

			

				
					
c++stl之set

				
			

			

				

					爱CV
				

				

					11-28
					
					386
					
				

			

		

		

			
				
set集合是c++ stl库中自带的一个容器，set具有以下两个特点：

1、set中的元素都是排好序的
	2、set集合中没有重复的元素
常用操作：

begin() 　　 返回set容器的第一个元素的地址
	end() 　　　返回set容器的最后一个元素地址
	clear() 　　 删除set容器中的所有的元素
	empty() 　 判断set容器是否为空
	max_size() 　 返回set容器可能包含的元素最大个数
	size() 　　　　返回当前set容器中的元素个数
	erase(it) ..

			
		

	





	

		

			

				
					
c++ bitset

				
			

			

				

					07-27
				

			

		

		

			
				
C++中的bitset是一种用于存储二进制数位的数据结构。它类似于一个bool类型的数组，但是每个元素只占用1 bit的空间，相当于一个char元素所占空间的八分之一。bitset的每个元素可以单独访问，就像数组一样。bitset有一个特性，即整数类型和布尔数组都可以转化成bitset。bitset的大小在编译时需要确定。如果需要不确定长度的bitset，可以使用vector。在C++中，可以使用bitset类来处理位集合，它提供了一些方便的方法来处理二进制位的有序集合。要使用bitset类，需要包含相关的头文件。\[1\]\[2\]\[3\]
#### 引用[.reference_title]
-  *1* *2* [c++ bitset 基本用法](https://blog.csdn.net/ywh15387127537/article/details/88707044)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item]
-  *3* [STL中便捷的bitset](https://blog.csdn.net/turkeyzhou/article/details/5902950)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item]
[ .reference_list ]

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 5

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值