bitset实现（转）

最新推荐文章于 2023-10-02 23:56:17 发布
最新推荐文章于 2023-10-02 23:56:17 发布
阅读量1k 收藏 1
点赞数
分类专栏： c++/c

感觉bitset实现很漂亮--所以转载

转自：http://blog.sina.com.cn.sixxs.org/u/1282003632

感谢原作者！

为了区分C++标准库中的bitset数据结构，在本程序中使用_bitset。
如果设置_bitset的长度为4，则可操作的位为0-3。
//_bitset.h
#ifndef _BITSET_H
#define _BITSET_H
#include <limits>
#include <cstring>
#include <iostream>
using namespace std;
class _bitset
{
 friend ostream & operator << (ostream & out,const _bitset & elem);   //重载输出操作符
public:
 typedef unsigned long block_type;   //最小存储单元块的类型
 typedef unsigned long size_type;    //最小存储单元块的大小类型
private:
 enum {BLOCK_BYTES = sizeof(block_type)};     //最小存储单元块的字节数
 enum {BLOCK_BITS = std::numeric_limits<block_type>::digits};  //最小单元存储块的位数，平台通用性，所以使用numeric_limits
public:
 _bitset();
 _bitset(size_type val);
 _bitset(const _bitset & val);
 _bitset & operator=(const _bitset & val);
 ~_bitset();
 _bitset & operator <<= (size_type num);  //左移赋值操作
 _bitset & operator >>= (size_type num);  //右移赋值操作
 _bitset & set(size_type pos,bool tagSet = true); //设置bitset中的某一位的值
 _bitset & clear(bool tagClear = true);    //使得bitset中每一位都为0
 _bitset & flip();       //反转所有位操作
 _bitset & operator ~();      //取反操作符
 _bitset & flip(size_type pos);    //反转pos位的操作
 bool test(size_type pos) const;    //测试相应位是1还是0
 _bitset & operator &= (const _bitset & val);
 _bitset & operator |= (const _bitset & val);
 _bitset & operator ^= (const _bitset & val);
 bool operator == (const _bitset & val) const;
 size_type size() const;
private:
 void leftShift(size_type num);   //左移操作
 void rightShift(size_type num);   //右移操作
private:
 size_type m_bitNum;   //bitset中位的个数
 size_type m_size;     //block_type的个数
 block_type * m_pBits; //存储bit位
 block_type m_mask;    //假如bitset的位数是5，而m_pBits[0]=0xFFFFFFFF,m_mask用来表示
                       //m_pBits[0]的后5位有效
};
_bitset operator << (const _bitset &,_bitset::size_type);
_bitset operator >> (const _bitset &,_bitset::size_type);
_bitset operator & (const _bitset &,const _bitset &);
_bitset operator | (const _bitset &,const _bitset &);
_bitset operator ^ (const _bitset &,const _bitset &);
inline _bitset::_bitset(size_type bitNum)
{
 m_bitNum = bitNum;
 size_type free_bits = (BLOCK_BITS - m_bitNum % BLOCK_BITS) % BLOCK_BITS;
 m_size = m_bitNum / BLOCK_BITS + (free_bits == 0 ? 0 : 1);
 m_pBits = new block_type[m_size];
 if (m_pBits == NULL)
 {
  cout << "no enough memorry!\n";
  exit(0);
 }
 clear();
 m_mask = ~block_type(0);
 m_mask >>= free_bits;
}
inline _bitset::_bitset(const _bitset &val)
{
 m_size = val.m_size;
 m_pBits = new block_type[m_size];
 if (m_pBits == NULL)
 {
  cout << "no enough memorry!\n";
  exit(0);
 }
 memcpy(m_pBits,val.m_pBits,m_size * BLOCK_BYTES);
 m_bitNum = val.m_bitNum;
 m_mask = val.m_mask;
}
inline _bitset & _bitset::operator =(const _bitset &val)
{
 if (this == &val)
  return (*this);
 if (m_size != val.m_size)
 {
  delete [] m_pBits;
  m_size = val.m_size;
  m_pBits = new block_type[m_size];
  if (m_pBits == NULL)
  {
   cout << "no enough memorry!\n";
   exit(0);
  }
 }
 memcpy(m_pBits,val.m_pBits,m_size * BLOCK_BYTES);
 m_bitNum = val.m_bitNum;
 m_mask = val.m_mask;
 return (*this);
}
inline _bitset::~_bitset()
{
 delete [] m_pBits;
}
inline _bitset & _bitset::operator <<=(_bitset::size_type num)
{
 leftShift(num);
 return (*this);
}
inline _bitset & _bitset::operator >>=(_bitset::size_type num)
{
 rightShift(num);
 return (*this);
}
inline _bitset::size_type _bitset::size() const
{
 return m_bitNum;
}
inline _bitset & _bitset::flip()
{
 for (size_type i=0;i<m_size;++i)
  m_pBits[i] = ~m_pBits[i];
 m_pBits[m_size-1] &= m_mask;
 return (*this);
}
inline _bitset & _bitset::operator~()
{
 return _bitset(*this).flip();
}
inline _bitset & _bitset::operator &=(const _bitset &val)
{
 if (m_bitNum != val.m_bitNum)
 {
  cout << "different length\n";
  exit(0);
 }
 for (size_type i=0;i<m_size;i++)
  m_pBits[i] &= val.m_pBits[i];
 return (*this);
}
inline _bitset & _bitset::operator |=(const _bitset &val)
{
 if (m_bitNum != val.m_bitNum)
 {
  cout << "different length\n";
  exit(0);
 }
 for (size_type i=0;i<m_size;i++)
  m_pBits[i] |= val.m_pBits[i];
 return (*this);
}
inline _bitset & _bitset::operator ^=(const _bitset &val)
{
 if (m_bitNum != val.m_bitNum)
 {
  cout << "different length\n";
  exit(0);
 }
 for (size_type i=0;i<m_size;i++)
  m_pBits[i] ^= val.m_pBits[i];
 return (*this);
}
inline bool _bitset::operator ==(const _bitset &val) const
{
 if (m_bitNum != val.m_bitNum)
  return false;
 for (size_type i=0;i < m_size;++i)
  if (m_pBits[i] != val.m_pBits[i])
   return false;
 return true;
}
inline _bitset operator << (const _bitset & val,_bitset::size_type num)
{
 return _bitset(val) <<= num;
}
inline _bitset operator >> (const _bitset & val,_bitset::size_type num)
{
 return _bitset(val) >>= num;
}
inline _bitset operator | (const _bitset & l,const _bitset & r)
{
 return _bitset(l) |= r;
}
inline _bitset operator & (const _bitset & l,const _bitset & r)
{
 return _bitset(l) &= r;
}
inline _bitset operator ^ (const _bitset & l,const _bitset & r)
{
 return _bitset(l) ^= r;
}
inline _bitset & _bitset::clear(bool tagClear)
{
 if (tagClear)
 {
  memset(m_pBits,0,m_size * BLOCK_BYTES);
 }
 else
 {
  memset(m_pBits,std::numeric_limits<unsigned char>::max(),m_size * BLOCK_BYTES);
  m_pBits[m_size-1] &= m_mask;
 }
 return (*this);
}
#endif
 
//_bitset.cpp
#include "_bitset.h"
void _bitset::leftShift(_bitset::size_type num)
{
 if (num >= m_bitNum)
 {
  clear();
  return;
 }
 size_type eleNum = num / BLOCK_BITS;
 size_type bitNum = num % BLOCK_BITS;
 if (eleNum != 0)
 {
  block_type * pTmp = new block_type[m_size];
  if (pTmp == NULL)
  {
   cout << "no enough memory\n";
   exit(0);
  }
  memcpy(pTmp,m_pBits,(m_size-eleNum)*BLOCK_BYTES);
  memcpy(m_pBits+eleNum,pTmp,(m_size-eleNum)*BLOCK_BYTES);
  memset(m_pBits,0,eleNum*BLOCK_BYTES);
  delete [] pTmp;
 }
 if (bitNum != 0)
 {
  block_type * pTmp = m_pBits + m_size -1;
  for (;pTmp > m_pBits;--pTmp)
  {
   *pTmp = (*pTmp << bitNum) | (*(pTmp-1) >> (BLOCK_BITS - bitNum)); //*pTmp的地位或上(*(pTmp-1))的高位
  }
  *pTmp <<= bitNum;
 }
 m_pBits[m_size-1] &= m_mask;  //将数组最高位的元素无用位置0
}
void _bitset::rightShift(_bitset::size_type num)
{
 if (num >= m_bitNum)
 {
  clear();
  return;
 }
 size_type eleNum = num / BLOCK_BITS;
 size_type bitNum = num % BLOCK_BITS;
 if (eleNum != 0)
 {
  block_type * pTmp = new block_type[m_size];
  if (pTmp == NULL)
  {
   cout << "no enough memory\n";
   exit(0);
  }
  memcpy(pTmp,m_pBits+eleNum,(m_size-eleNum)*BLOCK_BYTES);
  memcpy(m_pBits,pTmp,(m_size-eleNum)*BLOCK_BYTES);
  memset(m_pBits+m_size-eleNum,0,eleNum * BLOCK_BYTES);
  delete [] pTmp;
 }
 if (bitNum != 0)
 {
  block_type * pTmp = m_pBits;
  for (;pTmp < m_pBits + m_size -1;++pTmp)
  {
   *pTmp = (*pTmp >> bitNum) | (*(pTmp+1) << (BLOCK_BITS - bitNum));
  }
  *pTmp >>= bitNum;
 }
}
_bitset & _bitset::set(size_type pos,bool tagSet)
{
 if (pos > m_bitNum || pos < 0)
 {
  cout << "position is not right\n";
  exit(0);
 }
 
 size_type eleNum = pos / BLOCK_BITS;
 size_type bitNum = pos % BLOCK_BITS;
 block_type mask = 1;
 mask <<= bitNum;
 if (tagSet)
 {
  m_pBits[eleNum] |= mask;
 }
 else
 {
  m_pBits[eleNum] &= ~mask;
 }
 return (*this);
}
_bitset & _bitset::flip(_bitset::size_type pos)
{
 if (pos > m_bitNum || pos < 0)
 {
  cout << "position is not right\n";
  exit(0);
 }
 
 size_type eleNum = pos / BLOCK_BITS;
 size_type bitNum = pos % BLOCK_BITS;
 block_type mask = 1;
 mask <<= bitNum;
 m_pBits[eleNum] = m_pBits[eleNum] ^ mask;
 return (*this);
}
bool _bitset::test(_bitset::size_type pos) const
{
 if (pos > m_bitNum || pos < 0)
 {
  cout << "position is not right\n";
  exit(0);
 }
 
 size_type eleNum = pos / BLOCK_BITS;
 size_type bitNum = pos % BLOCK_BITS;
 block_type mask = 1;
 mask <<= bitNum;
 return m_pBits[eleNum] & mask;
}
ostream & operator << (ostream & out,const _bitset & elem)
{
 _bitset::size_type j = 0;
 _bitset::size_type mask = 1;
 mask <<= (elem.m_bitNum % _bitset::BLOCK_BITS-1);
 for (_bitset::size_type i = elem.m_bitNum-1;i>0;i--)
 {
  if (i % (_bitset::BLOCK_BITS) == 0)
  {
   j++;
   mask = 1;
   mask <<= (_bitset::BLOCK_BITS-1);
  }
  if (elem.m_pBits[elem.m_size-j-1] & mask)
  {
   out << 1;
  }
  else
  {
   out << 0;
  }
  mask >>= 1;
 }
 return out;
}
 
//main 测试函数
#include <iostream>
#include <bitset>
#include <limits>
#include "_bitset.h"
using namespace std;
int main()
{
 bitset<4> mybits;
 //cout << mybits << endl;
 cout << mybits.set(3) << endl;
 _bitset bit(34);
 bit.set(33);
 //bit.rightShift(1);
 //bit <<= 1;
 cout << bit << endl;
}

bitset数据结构能够有效的节约存储空间，在海量数据排序，海量数据检索中都有用处。



xw_njust_ecjtu
关注
专栏目录
关于bitset的实现
weixin_44288817的博客
04-21 1532
这算不算我的第一篇解题报告？虽然不是算法题。 原题：程序填空，实现一个类似于STL中bitset的MyBitset，输出指定结果。 #include <iostream> #include <cstring> using namespace std; template <int bitNum> struct MyBitset { char a[bitNum/...
Base64 基于C++ bitset实现。
Newzai的专栏
05-06 1714
Base64基础知识可以参考此文章，非常详细：http://blog.csdn.net/morewindows/article/details/11871429 转换为Base64，输入数据必须以三个字节为一组，转为为4个字节的可视字符。下面主要是根据下图的映射表就行编程： 以下代码实现了Base64的编码规则 #include #include #include
c++ bitset实现
07-24
自己实现的bitset数据结构，在vs2005下编译通过。有测试成素。
BitSet的实现原理
热门推荐
forever-and-ever的博客
08-31 2万+
1.BitSet介绍 Bitset是Java中的一种数据结构。Bitset中主要存储的是二进制位，做的也都是位运算，每一位只用来存储0，1值，主要用于对数据的标记。 Bitset的基本原理是，用1位来表示一个数据是否出现过，0为没有出现过，1表示出现过。使用的时候可以根据某一个位是否为0表示此数是否出现过。JDK中的BitSet集合对是布隆过滤器中经常使用的数据结构Bitmap的相对简单的实现...
位集Bitset的实现
我的博客
12-01 273
本次带来Bitset模板库，除了跟标准库作全部兼容之外，还对C++14及以上版本环境进行了优化，可将对象声明为constexpr。 编译环境：C++11 源码： #ifndef BITSET_H #define BITSET_H #include <iosfwd> #include <string> #if __cplusplus >= 201703L #define CXX17_CONSTEXPR constexpr #else #define CXX17_CO
位图的实现(BitSet)
rootDream的博客
02-22 347
位图的实现(BitSet) 使用bloomfilter算法实现。可以解决缓存穿透问题。 思路：将数据库中表的键存储在bloomfilter中，前端访问该bloomfilter，若判断可能存在就放过，否则，直接返回非法访问。容错率不高，但也有效保证性能，将大量访问降低到少量访问。(防止黑客恶意攻击。) 问题： 怎么判断1亿 数据里面是否存在某个数据？要求算法的复杂度，控制在常数范围内！ 14亿人身份...
Go-bitset-Go包实现bitsets
08-14
Go的`bitset`包实现了这个概念，提供了快速的插入、删除和查询操作，对于处理大量布尔状态或者节省内存非常有用。在本文中，我们将深入探讨`bitset`包的实现和使用方法。 1. **bitset的基本概念** - 位集是用二...
动态Bitset源代码
09-30
在C++的STL中实现由一个bitset类模板，其用法如下： std::bitset<64> bs; 也就是说，这个bs只能支持64位以内的位存储和操作；bs一旦定义就不能动态增长了。本资源附件中实现了一个动态Bitset，和标准bitset兼容。 /*...
golang实现位图(BitSet)
kdpujie的专栏
02-22 4537
一, 概念      Bitmap (位图)是一个十分有用的数据结构。所谓的 Bit-map 就是用一个 bit 位来标记某个元素对应的 Value，而 Key 即是该元素。由于采用了 Bit 为单位来存储数据，因此在内存占用方面，可以大大节省。（《编程珠玑》第一章引入的问题，提到了 Bitmap） 二, 实现基本原理      类似于java的BitSet, 是位操作的对象
bitset
jkchen's Haven
03-22 350
bitset用于存储二进制数位。 bitset就像一个bool类型的数组，一个元素一般只占1 bit，相当于一个char元素所占空间的八分之一。 bitset中的每个元素都能单独被访问，例如对于一个叫做foo的bitset，表达式foo[3]访问了它的第4个元素，就像数组一样。 特性：整数类型和布尔数组都能转化成bitset。 bitset的大小在编译时就需要确定。如果你想要不确定长度的bits...
bitset（位图）的使用与模拟实现
平淡中造就不平凡
04-26 972
所谓位图，就是用每一位来存放某种状态，适用于海量数据，数据无重复的场景。通常是用来判断某个数据存不存在的。
＜C++＞ STL_bitset使用和模拟实现
最新发布
ikun66666的博客
10-02 1069
bitset的使用和模拟实现
自己实现的Bitset类
imgen的专栏
04-03 1390
自己用C++实现的Bitset类, 功能参考STL的bitset类, 由于VS2005不支持模板的分离编译, 所以都实现在了一个名为Bitset.h的头文件里. 肯定有一些bug, 请各位高手帮忙抓虫. 抛砖引玉, 博大家一晒. 1: #ifndef BIT_SET_H 2: #define BIT_SET_H 3: //Readme 4: //本程序实现了一个类似std:
C++ bitset的实现
taoqick的专栏
10-22 2114
C++中bitset很方便的实现了位操作，有几点需要注意，可以参考源代码： https://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-html-USERS-4.2/bitset-source.html 它的模板是 00645 template 00646 class bitset 00647 : private _B
bitset实现
weixin_30566149的博客
12-07 153
　　最近看到C++的bitset，突然好奇他们是怎么实现的。对内存的管理不可避免要用到指针，可是指针是用类型的，对bit的管理用什么指针效率高呢？于是就自己尝试写了个用char*来管理内存的bitset，当然自己这个效率稳健都无法于源码相比，所以命名成BitMap，只当是练习了。不过经过我的测试，发现这种方法的效率并不比c++的bitset效率低。　　 　　主要代码如下(Download)： ...
自己写了一个c++ bitset，功能非常齐全！
爱读庄子的码农
05-25 4792
c++ bitset用途很广，而理解它的最好方式莫过于自己写一个，重新造轮子还是非常有乐趣的，废话不多说了，贴代码。 首先是一些必要的函数，封装在名字空间mystd里面。
bitset类的实现
hello world@2012
05-13 1426
问题：实现一个bitmap类（为避免与stl中的bitset重名），用于位图。 测试用例： BitMap bm(20); bm[3] = 1; bm[5] = 0; bool b = bm[12]; 其本质上是用内存中的一位来表示某种意义。 难点在于，使用int或者unsigned int类型保存多位bool变量（也就是0或者1）后，怎么重载下标操作符。 如果不使用下标而是使用函数，例如
C++——std::Bitset（转载）
游走的鱼
12-07 1849
这一篇文章系统的学习一下std标准库中的容器bitset，一个bitset是用来储存诸多bit，这些元素可以用来表示两种状态：0或1，true或false…。所以有一些时候可以很方便的用该容器快速实现状态储存。该容器通过对空间的特殊优化，使得该容器对状态的储存空间非常小，相当于将若干状态储存在一个个bit上。该容器的元素访问也可以通过[n]访问容器中第n个元素，但是由于一般语言没有一个bit大小的数据类型，所以这里使用了一种特殊的引用类型访问，如：bitset::reference。 构造一个bitset，
bitset的一个简单实现
心若微尘的博客
07-19 1199
bitset的一个简单实现 最近有一个上亿的数据（数据较平均，重复量较小）进行排重的需求，综合考虑了各种方案，最后想到了一个简单的方案： 假设有1亿条数据需要排重，每条数据的关键字有40个字节，考虑使用hash_map,但是放入内存的话需要的内存最少为 100000000 * 40 / 1024 / 1024 / 1024 = 3.7252902984619140625 G 这是不能被接受...
Java BitSet源码解析：进阶必读
源码中的注释提到，`BitSet`实现了`Serializable`接口，这意味着它可以被序列化和反序列化，方便在网络间传输或者持久化到磁盘。此外，它还支持`IO`操作，如`readObject`和`writeObject`方法，以适应数据的输入输出...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值