bitset类基本用法

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

#include <bitset>
using std::bitset;

bitset定义和初始化

bitset<num> b;      //b有n位，每位都为0  
bitset<num> b(u);   //b是unsigned long型u的一个副本  
bitset<num> b(s);   //b是string对象s中含有位串的副本,所谓位串即01二进制组成的字符串
bitset<num> b(s, n);//b是s中n位后的位串的副本
bitset<num> b(s, pos, n);//b是s中从位置pos开始向后n位的副本

such as:
string s("101011001101");
bitset<16> b(s, 5);//从第五位向后 0000000001001101
bitset<16> b(s, 3, 5);//0000000000001100

类似于vector，bitset类是一种类模板；而与vector不一样的是bitset类型对象的区别仅在其长度而不在其类型。在定义bitset时，要明确bitset含有多少位，须在尖括号内给出它的长度值。给出的长度值必须是常量表达式。长度值必须定义为整型字面值常量或是已用常量值初始化的整数类型的const对象。bitset中的位是没有命名的，程序员只能按位置来访问它们。位集合的位置编号从0开始。
当用string对象初始化bitset对象时，string对象直接表示为位模式。从string对象读入位集的顺序是从右向左，string对象和bitset对象之间是反向转化的：string对象的最右边字符（即下标最大的那个字符）用来初始化bitset对象的低阶位（即下标为0的位）。当用string对象初始化bitset对象时，记住这一差别很重要。不一定要把整个string对象都作为bitset对象的初始值。相反，可以只用某个子串作为初始值。

string str("1111111000000011001101");  
bitset<32> bitvec5(str, 5, 4); // 4 bits starting at str[5], 1100  
bitset<32> bitvec6(str, str.size() - 4);     // use last 4 characters 

这里用str中从str[5]开始包含四个字符的子串来初始化bitvec5。照常，初始化bitset对象时总是从子串最右边结尾字符开始的，bitvec5的从0到3的二进制位置为1100，其他二进制位都置为0。如果省略第三个参数则意味着取从开始位置一直到string末尾的所有字符。本例中，取出str末尾的四位来对bitvec6的低四位进行初始化。bitvec6其余的位初始化为0。这些初始化过程的图示如下：

bitset的上的操作

b.any()         b中是否存在置为1的二进制位？
b.none()        b中不存在置为1的二进制位？
b.count()       b中置为1的二进制位的个数
b.size()        b中二进制位的个数
b[pos]          访问b中在pos处的二进制位
b.test(pos)     b中在pos出的二进制位是否为1？
b.set()         把b中所有二进制位都置为1
b.set(pos)      把b中在pos出的二进制位置为1
b.reset()       把b中所有二进制位置都置为0
b.reset(pos)    把b中在pos处的二进制位置为0
b.flip()        把b中所有二进制位逐位取反
b.flip(pos)     把b中pos处的二进制位取反
b.to_ulong()    用b中同样的二进制位返回一个unsigned long值
os << b         把b中的位集输出到os流

测试整个bitset对象

如果bitset对象中有一个或多个二进制位置为1，则any操作返回true，也就是说，其返回值等于1;相反，如果bitset对象中的二进制位全为0,则none操作返回true。如果需要知道置为1的二进制位的个数，可以使用count操作，该操作返回置为1的二进制位的个数：

bitset<32> bitvec;                   // 32 bits, all zero  
bool is_set = bitvec.any();          // false, all bits are zero  
bool is_not_set = bitvec.none();     // true, all bits are zero  

size_t bits_set = bitvec.count();    // returns number of bits that are on

count操作的返回类型是标准库中命名为size_t的类型。size_t类型定义在cstddef头文件中，该文件是C标准库的头文件stddef.h的C++版本。它是一个与机器相关的unsigned类型，大小可以保证存储内存中对象。与vector和string中的size操作一样，bitset的size操作返回bitset对象中二进制位的个数，返回值的类型是size_t：

size_t sz = bitvec.size(); // returns 32

访问bitset对象中的位

可以用下标操作符来读或写某个索引位置的二进制位，同样地，也可以用下标操作符测试给定二进制位的值或设置某个二进制位的值：

// assign 1 to even numbered bits  
for (int index = 0; index != 32; index += 2)  
    bitvec[index] = 1;

上面的循环把bitvec中的偶数下标的位都置为1。除了用下标操作符，还可以用set、test和reset操作来测试或设置给定二进制位的值：

// equivalent loop using set operation  
for (int index = 0; index != 32; index += 2)  
    bitvec.set(index); 

为了测试某个二进制位是否为1，可以用test操作或者测试下标操作符的返回值：

if (bitvec.test(i))  
    // bitvec[i] is on  
// equivalent test using subscript  
if (bitvec[i])  
    // bitvec[i] is on

如果下标操作符测试的二进制位为1，则返回的测试值的结果为true，否则返回false。

对整个bitset对象进行设置

set和reset操作分别用来对整个bitset对象的所有二进制位全置1和全置0：

bitvec.reset();    // set all the bits to 0
bitvec.set();      // set all the bits to 1

flip操作可以对bitset对象的所有位或个别位按位取反：

bitvec.flip(0);   // reverses value of first bit  
bitvec[0].flip(); // also reverses the first bit  
bitvec.flip();    // reverses value of all bits  

获取bitset对象的值

to_ulong操作返回一个unsigned long值，该值与bitset对象的位模式存储值相同。仅当bitset类型的长度小于或等于unsigned long的长度时，才可以使用to_ulong操作：

unsigned long ulong = bitvec3.to_ulong();  
cout << "ulong = " << ulong << endl;  

to_ulong操作主要用于把bitset对象转到C风格或标准C++之前风格的程序上。如果bitset对象包含的二进制位数超过unsigned long的长度，将会产生运行时异常。

输出二进制位

可以用输出操作符输出bitset对象中的位模式：

bitset<32> bitvec2(0xffff); // bits 0 ... 15 are set to 1; 16 ... 31 are 0  
cout << "bitvec2: " << bitvec2 << endl; //00000000000000001111111111111111 

使用位操作符

bitset类也支持内置的位操作符。C++定义的这些操作符都只适用于整型操作数，它们所提供的操作类似于本节所介绍的bitset操作。

#include <iostream>  
#include <bitset>  
using namespace std;  

int main(){  
    //bitset 使用整数初始化bitset  
    bitset<3> bs(7);  
    //输出bs各个位的值  
    cout<<"bs[0] is "<<bs[0]<<endl;  
    cout<<"bs[1] is "<<bs[1]<<endl;  
    cout<<"bs[2] is "<<bs[2]<<endl;  
    //下面的语句会抛出outofindexexception  
    //cout<<"bs[3] is "<<bs[3]<<endl;  

    //使用字符串初始化bitset  
    //注意：使用string初始化时从右向左处理，如下初始化的各个位的值将是110，而非011  
    string strVal("011");  
    bitset<3> bs1(strVal);  
    //输出各位    
    cout<<"bs1[0] is "<<bs1[0]<<endl;  
    cout<<"bs1[1] is "<<bs1[1]<<endl;  
    cout<<"bs1[2] is "<<bs1[2]<<endl;  
    //cout输出时也是从右边向左边输出  
    cout<<bs1<<endl;  

    //bitset的方法  
    //any()方法如果有一位为1，则返回1  
    cout<<"bs1.any() = "<<bs1.any()<<endl;  

    //none()方法，如果有一个为1none则返回0，如果全为0则返回1  
    bitset<3> bsNone;  
    cout<<"bsNone.none() = " <<bsNone.none()<<endl;  

    //count()返回几个位为1  
    cout<<"bs1.count() = "<<bs1.count()<<endl;  

    //size()返回位数  
    cout<<"bs1.size() = "<<bs1.size()<<endl;  

    //test()返回某一位是否为1  
    //flip()诸位取反  
    bitset<3> bsFlip = bs1.flip();  
    cout<<"bsFlip = "<<bsFlip<<endl;  

    //to_ulong  
    unsigned long val = bs1.to_ulong();  
    cout<<val;  
}  

示例代码

#include <bitset>
#include <string>
#include <iostream>
#include <climits>

int main() 
{
    // empty constructor
    std::bitset<8> b1; // [0,0,0,0,0,0,0,0]

    // unsigned long long constructor
    std::bitset<8> b2(42);          // [0,0,1,0,1,0,1,0]
    std::bitset<70> bl(ULLONG_MAX); // [0,0,0,0,0,0,1,1,1,...,1,1,1] in C++11
    std::bitset<8> bs(0xfff0);      // [1,1,1,1,0,0,0,0]

    // string constructor
    std::string bit_string = "110010";
    std::bitset<8> b3(bit_string);       // [0,0,1,1,0,0,1,0]
    std::bitset<8> b4(bit_string, 2);    // [0,0,0,0,0,0,1,0]
    std::bitset<8> b5(bit_string, 2, 3); // [0,0,0,0,0,0,0,1]

    // string constructor using custom zero/one digits
    std::string alpha_bit_string = "aBaaBBaB";
    std::bitset<8> b6(alpha_bit_string, 0, alpha_bit_string.size(),
                      'a', 'B');         // [0,1,0,0,1,1,0,1]

    // char* constructor using custom digits
    std::bitset<8> b7("XXXXYYYY", 8, 'X', 'Y'); // [0,0,0,0,1,1,1,1]

    std::cout << b1 << '\n' << b2 << '\n' << bl << '\n' << bs << '\n'
              << b3 << '\n' << b4 << '\n' << b5 << '\n' << b6 << '\n'
              << b7 << '\n';
}

output：
00000000
00101010
0000001111111111111111111111111111111111111111111111111111111111111111
11110000
00110010
00000010
00000001
01001101
00001111

github-bitset代码：
https://github.com/chensguo8099/c-code/tree/master/cpp_primer/firstStep