bitset用法

<pre name="code" class="cpp">#include<iostream>
#include<bitset>
using   namespace  std;
int  main()
{
    bitset<4> bit(1111);
    cout<<bit.to_ulong()<<endl;
    cout << bit << endl;
    string bita("1111");
    bitset<4> bs(bita);
    cout << bita << endl;
    ///cout << bita.to_ulong()<< endl; 此句错误
    bitset<4> ait(1001);
    cout<<ait.to_ulong()<<endl;
    return 0;
}

<pre name="code" class="cpp">/*
7
0111
1111
9

Process returned 0 (0x0)   execution time : 0.477 s
Press any key to continue.

*/

问题补充：
那对于以下的代码呢 编译结果为9 如何解释呢 #include<iostream>#include<bitset>using namespace std;void main(){ bitset<5> a(00111); cout<<a.to_ulong();}
 
回答如下：
MSDN上如是说：
bitset(unsigned long val);
The constructor sets only those bits at position j for which val & 1 << j is nonzero.
理解上面的这段话后， 用计算器计算得到：
D(1111) = B(10001010111)
D(1001) = B(1111101001)
D为十进制,B为二进制 而你定义的bitset<4>，只有四位，那么取1111的二进制的最后四位即0111,得十进制7，同理1001得到1001，即十进制9
 
ps:对于你上面补充的，我想说如果是bitset<5> (111),那么这个111是十进制，但是当你变成bitset<5>(00111）或是bitset<5>(0111),那么这个111是八进制，也就是十进制的73,即1001001，取后面五位即9 再说得细一点，bitset<N>(M)中的N指明内存中的位数，二进制。
M指明数的大小，至于这个数的进制，你可以查一下资料，C语言中在一个整数前面加0表示八进制，在一个整数前加0x代表十六进制。

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

#include <bitset>
using std::bitset;
1.bitset定义和初始化
          以下列出了bitset的构造函数：

bitset<n> b;            //b有n位，每位都为0
bitset<n> b(u);             //b是unsigned long型u的一个副本
bitset<n> b(s);             //b是string对象s中含有的位串的副本
bitset<n> b(s, pos, n);     //b是s中从位置pos开始的n个位的副本
         类似于vector，bitset类是一种类模板；而与vector不一样的是bitset类型对象的区别仅在其长度而不在其类型。在定义bitset时，要明确bitset含有多少位，须在尖括号内给出它的长度值：
[cpp] view plain copy
bitset<32> bitvec; //32位，全为0。
         给出的长度值必须是常量表达式。正如这里给出的，长度值必须定义为整型字面值常量或是已用常量值初始化的整数类型的const对象。
       这条语句把bitvec定义为含有32个位的bitset对象。和vector的元素一样，bitset中的位是没有命名的，程序员只能按位置来访问它们。位集合的位置编号从0开始，因此，bitvec的位序是从0到31。以0位开始的位串是低阶位（low-order bit），以31位结束的位串是高阶位(high-order bit)。
1.1用unsigned值初始化bitset对象
         当用unsigned long值作为bitset对象的初始值时，该值将转化为二进制的位模式。而bitset对象中的位集作为这种位模式的副本。如果bitset类型长度大于unsigned long值的二进制位数，则其余的高阶位置为0；如果bitet类型长度小于unsigned long值的二进制位数，则只使用unsigned值中的低阶位，超过bitet类型长度的高阶位将被丢弃。
       在32位unsigned long的机器上，十六进制值0xffff表示为二进制位就是十六个1和十六个0（每个0xf可表示为1111）。可以用0xffff初始化bitset对象：

// bitvec1 is smaller than the initializer
bitset<16> bitvec1(0xffff);          // bits 0 ... 15 are set to 1
// bitvec2 same size as initializer
bitset<32> bitvec2(0xffff);          // bits 0 ... 15 are set to 1; 16 ... 31 are 0
// on a 32-bit machine, bits 0 to 31 initialized from 0xffff
bitset<128> bitvec3(0xffff);         // bits 32 through 127 initialized to zero
         上面的三个例子中，0到15位都置为1。由于bitvec1位数少于unsigned long的位数，因此bitvec1的初始值的高阶位被丢弃。bitvec2和unsigned long长度相同，因此所有位正好放置了初始值。bitvec3长度大于32，31位以上的高阶位就被置为0。
1.2用string对象初始化bitset对象
         当用string对象初始化bitset对象时，string对象直接表示为位模式。从string对象读入位集的顺序是从右向左：

string strval("1100");
bitset<32> bitvec4(strval);
         bitvec4的位模式中第2和3的位置为1，其余位置都为0。如果string对象的字符个数小于bitset类型的长度，则高阶位将置为0。
       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。这些初始化过程的图示如下：

2.bitset的上的操作
          多种bitset操作用来测试或设置bitset对象中的单个或多个二进制位：

2.1测试整个bitset对象
           如果bitset对象中有一个或多个二进制位置为1，则any操作返回true，也就是说，其返回值等于1;相反，如果bitset对象中的二进制位全为0,则none操作返回true。

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
          如果需要知道置为1的二进制位的个数，可以使用count操作，该操作返回置为1的二进制位的个数：

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
2.2访问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。
2.3对整个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
2.4获取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的长度，将会产生运行时异常。
2.5输出二进制位
           可以用输出操作符输出bitset对象中的位模式：

bitset<32> bitvec2(0xffff); // bits 0 ... 15 are set to 1; 16 ... 31 are 0
cout << "bitvec2: " << bitvec2 << endl;
           输出结果为：

bitvec2: 00000000000000001111111111111111
2.6使用位操作符
          bitset类也支持内置的位操作符。C++定义的这些操作符都只适用于整型操作数，它们所提供的操作类似于本节所介绍的bitset操作。
3.程序实例
*/
#include <iostream>
#include <bitset>
using namespace std;

int main(){
    //bitset 使用整数初始化bitset
    bitset<3> bs(2);///bitset<m>bs(n)  将n写成二进制数 但是只有后m位 不存在的位 用0 补
    //输出bs各个位的值
    cout<<"bs[0] is "<<bs[0]<<endl;
    cout<<"bs[1] is "<<bs[1]<<endl;
    cout<<"bs[2] is "<<bs[2]<<endl;
    //下面的语句会抛出 out of index exception
    //cout<<"bs[3] is "<<bs[3]<<endl;

    //使用字符串初始化bitset
    //注意：使用string初始化时从右向左处理，如下初始化的各个位的值将是110，而非011
    ///string strVal("11011"); /// 这样写的话， 输出将为： 0 1 1       110
    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;
    cout<<"bs1.none() = " <<bs1.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;
}
/*
bs[0] is 0
bs[1] is 1
bs[2] is 0
bs1[0] is 1
bs1[1] is 1
bs1[2] is 0
011
bs1.any() = 1
bsNone.none() = 1
bs1.none() = 0
bs1.count() = 2
bs1.size() = 3
bsFlip = 100
4
Process returned 0 (0x0)   execution time : 0.603 s
Press any key to continue.

*/