Boost (2): dynamic_bitset二进制数

/*
*  boost库中数据容器之一：dynamic_bitset
*   配置环境： win32 + codeblock + mingw32-g++ + boost.1.66
*   author  : Ranger_roger
*   time    : 2018//3/2
*
*  采用位运算往往可以取得意想不到的性能提升，位运算必然和二进制位数关联，C++为二进制位数提
*  供了两个工具std::vector<bool>和std::bitset
*  前者并不是容器，虽可动态增长，但是位运算受限；后者的bitset是标准容器，支持多样的位运算
*  但是大小固定，无法动态增长size。
*  boost::dynamic_bitset则是综合两者的优点
*/

/*
template <typename Block, typename Allocator>
//Block指示以何种整数类型存储二进制位，必须是一个无符号整数，默认是unsigned long，如果二进制
//数不超过32位，为节省空间，可以采用更小的Block类型，如果unsigned char unsigned short
//Allocator是类内部使用的内存分配器，默认为std::allocator<Block>，一般这两个模板形参无需变动
class dynamic_bitset
{
// Portability note: member function templates are defined inside
// this class definition to avoid problems with VC++. Similarly,
// with the member functions of nested classes.
//
// [October 2008: the note above is mostly historical; new versions
// of VC++ are likely able to digest a more drinking form of the
// code; but changing it now is probably not worth the risks...]

BOOST_STATIC_ASSERT((bool)detail::dynamic_bitset_impl::allowed_block_type<Block>::value);
typedef std::vector<Block, Allocator> buffer_type;

public:
typedef Block block_type;
typedef Allocator allocator_type;
typedef std::size_t size_type;
typedef typename buffer_type::size_type block_width_type;

BOOST_STATIC_CONSTANT(block_width_type, bits_per_block = (std::numeric_limits<Block>::digits));
BOOST_STATIC_CONSTANT(size_type, npos = static_cast<size_type>(-1));

explicit dynamic_bitset();   //显式的无参构造函数，拒绝隐式调用
dynamic_bitset(const dynamic_bitset& b);

void swap(dynamic_bitset& b);   //基本操作集合
void resize(size_type num_bits, bool value = false);
void clear();
void push_back(bool bit);
void append( Block block);
//注意因为dynamic_bitset也并非严格意义上的容器，故而也没有begin()和end()迭代器遍历接口

bool  operator[](size_type pos) const; //操作符[]重载
dynamic_bitset& operator&=(const dynamic_bitset& b);
dynamic_bitset& operator|=(const dynamic_bitset& b);
...

dynamic_bitset&  set();     //bit翻转
dynamic_bitset&  reset();
dynamic_bitset&  flip();    //位图取反

bool test(size_type n) const;  //bit测试
bool any() const;     //检测位图，若有任意1，则返回true
bool none() const;    //检测位图，若有任意1，则返回false
dynamic_bitset operator~() const; //重载取反符号
size_type  count() const;  //检测位图中有1的数目

unsigned long to_ulong() const; //转型到ulong
size_type  size() const;
size_type  num_blocks() const;
size_type  max_size() const;
bool       empty() const;

bool is_subset_of(const dynamic_bitset& a) const; //集合操作
bool is_proper_subset_of(const dynamic_bitset& a) const;

size_type find_first() const;
size_type find_next(size_type pos) const;
*/

#include <iostream>
#include <string>
#include <boost/dynamic_bitset.hpp>
#include <boost/utility.hpp> //定义了BOOST_BINARY宏

using namespace std;
using namespace boost;

int main()
{
dynamic_bitset<> db1;
dynamic_bitset<> db2(10);
dynamic_bitset<> db3(0x16,
BOOST_BINARY(10101));
//大小为22，并采用boost的编译器宏BOOST_BINARY在编译器直接创建一个二进制数，没有运行时开销
dynamic_bitset<> db4(string("0100"));//使用string构建临时对象，存在运行期开销
dynamic_bitset<> db5(db3);

dynamic_bitset<> db6;
db6 = db4;

cout << hex << db5.to_ulong() << endl; //转换为整数, 0x15 = 21
cout << db4[0] << db4[1] << db4[2] << endl; //dynamic_bitset从高到低存储二进制位，即[0]对应最低位
cout << db2 << endl;
cout << db6 << endl;

//“容器”操作
cout << "*****************size-related operation resize/size/clear" << endl;
db2.resize(20, true); //扩展
cout << db2 << endl;
db2.resize(15);  //收缩
cout << db2 << endl;
db2.clear();     //清空
cout << "db2:" << db2 << endl;

assert(db2.size() == 0 && db2.empty() ); //判断db2是否为空

//判断一个dynamic_bitset占据了几个block，如果block是默认的unsigned long,则对应为8*8即64个字节
//assert(dynamic_bitset<>(64).num_blocks() == 2);
assert(dynamic_bitset<>(65).num_blocks() == 3);
cout << dynamic_bitset<>(64).num_blocks() << endl; //2
cout << sizeof(unsigned long) << endl; //4

cout << db6 << endl;  //0100
cout << db6.size() << endl; //4
db6.append(BOOST_BINARY(101));
cout << db6 << endl; //000000000000000000000000000000001010100
cout << db6.size() << endl; //24

//位运算操作，使用了代理技术，存在class class的内部类，用以完成细粒度元素的位运算
cout << "*****************bit-op operation ^/&/|" << endl;
dynamic_bitset<> db7(4, BOOST_BINARY(1010));
db7[0] &= 1;  //与
db7[1] ^= 1;  //异或
cout << db7 << endl; //1000

dynamic_bitset<> db8(4, BOOST_BINARY(0101));
assert(db7 > db8 );

cout << (db7 ^ db8) << endl; //1101
cout << (db7 | db8) << endl; //1101
cout << (db7 & db8) << endl; //0000

//返回元素
cout << "*****************statistical operation test/any/none/count" << endl;
cout << db8.test(0) << endl; //查看二进制数的第n位是否为1 //1
cout << db8.any() << endl; //查看二进制数是否有任意1  //1
cout << db8.none() << endl; //any的反操作  //0
cout << db8.count() << endl; //统计db8中所有值为1的元素的数量 //2
cout << db8.find_first() << endl; //从第0位置开始查找，返回第一个值为1的位置
cout << db8.find_next(0) << endl; //从第n位置开始查找，返回第一个值为1的位置，若找不到则返回npos

cout << "*****************reverse operation set/reset/flip" << endl;
cout << db8 << endl; //0101
db8.set(); //可以置全部或特定位置为1或0,默认是1
cout << db8 << endl; //1111
db8.reset(); //可以置全部或特定为0
cout << db8 << endl; //0000
db8.flip();//将特定位置或全部位置翻转
cout << db8 << endl; //1111

cout << "*****************type conversion to_ulong/to_string" << endl;
cout << std::dec << db8.to_ulong() << endl;
string str;
to_string(db8, str);
cout << str << endl;

cout << "*****************list operation is_subset_of/is_proper_subset_of" << endl;
dynamic_bitset<> db9(4, BOOST_BINARY(11)); //即便是做子集判断，依旧要求两个dynamic_bitset的size是等价的
dynamic_bitset<> db10(db8);
assert(db9.is_proper_subset_of(db8)); //真子集
assert(db10.is_subset_of(db8)); //子集

cout << "*****************a demo for selecting prime number" << endl;
int n;
cin >> n;
dynamic_bitset<> db(n); //初始化为size=n,全部位置为1

db.set(); //翻转，全部置为1

for (dynamic_bitset<>::size_type i = db.find_next(1);
i != dynamic_bitset<>::npos;
i = db.find_next(i) ) //因为dynamic_bitset不是标准容器，所以不能使用迭代器，也不能用for+auto范围迭代
{
for (dynamic_bitset<>::size_type j = db.find_next(i);
j != dynamic_bitset<>::npos;
j = db.find_next(j))
{
if (j % i == 0)
{
db[j] = 0;
}
}
}

for (dynamic_bitset<>::size_type i = db.find_next(2);
i != dynamic_bitset<>::npos;
i = db.find_next(i))
{
cout << i << ", ";
}  //如输入10，则打印： 3， 5， 7，
return 0;
}