STL bitset用法总结
2017-09-12 11:17
309 查看
c++ bitset类用法:http://blog.csdn.net/qll125596718/article/details/6901935
C++ 参考:http://www.cplusplus.com/reference/bitset/bitset/
http://happyboy200032.blog.163.com/blog/static/46903113201291252033712/
http://blog.csdn.net/e6894853/article/details/7925846
有些程序要处理二进制位的有序集,每个位可能包含的是0(关)或1(开)的值。位是用来保存一组项或条件的yes/no信息(有时也称标志)的简洁方法。标准库提供了bitset类使得处理位集合更容易一些。要使用bitset类就必须要包含相关的头文件。在本书提供的例子中,假设都使用了std::bitset的using声明:
[cpp] view
plain copy
#include <bitset>
using std::bitset;
[cpp] view
plain copy
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)。
在32位unsigned long的机器上,十六进制值0xffff表示为二进制位就是十六个1和十六个0(每个0xf可表示为1111)。可以用0xffff初始化bitset对象:
[cpp] view
plain copy
// 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。
[cpp] view
plain copy
string strval("1100");
bitset<32> bitvec4(strval);
bitvec4的位模式中第2和3的位置为1,其余位置都为0。如果string对象的字符个数小于bitset类型的长度,则高阶位将置为0。
string对象和bitset对象之间是反向转化的:string对象的最右边字符(即下标最大的那个字符)用来初始化bitset对象的低阶位(即下标为0的位)。当用string对象初始化bitset对象时,记住这一差别很重要。
不一定要把整个string对象都作为bitset对象的初始值。相反,可以只用某个子串作为初始值:
[cpp] view
plain copy
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操作
bitset的函数用法
std::bitset是STL的一个模板类,它的参数是整形的数值,使用位的方式和数组区别不大,相当于只能存一个位的数组。下面看一个例子
[cpp] view
plain copy
bitset<20> b1(5);
cout<<"the set bits in bitset<5> b1(5) is:"
<< b1 <<endl;
结果是 the set bits in bitset<5> b1(5) is:00000000000000000101
它是以整数5传递进去,而以二进制数打印出来。
bitset还可以用作字符串转为整型
[cpp] view
plain copy
string bitval2;
cin>>bitval2;
// int length = strlen("11101101100");
// bitset<11>b2(bitval2);
bitset<11> b2(bitval2);
cout<<b2<<"is "<<b2.to_ulong()<<endl;
以及整形转为字符串
[cpp] view
plain copy
int interge1;
cin>>interge1;
cout<<"************整数转为字符串**************"<<endl;
bitset<11>b3(interge1);
cout<<b3.to_ulong()<<"is "<<b3.to_string()<<endl;
注意事项
你看得出来下面的代码为什么输出7和9吗?
#include<iostream>
#include<bitset>
using namespace std;
void main()
{
bitset<4> bit(1111);
cout<<bit.to_ulong()<<endl;
bitset<4> ait(1001);
cout<<ait.to_ulong()<<endl;
}
原因很简单:bitset调用的构造函数,1111为十进制,换成二进制为 0x10001010111,最后4位为0111,输出就是7;如果你想规定bitset里面的每一位,那么最好用string类 型:bitset<4> bits("1111"); 这样输出就是15了。
字符串合并以及输出的问题,要搞定,还真麻烦......为了偷懒,在多个类型之间转来转去的......不过写起来真的很简单,哈哈!有现成的方法就用呗!不管效率了......
#include <iostream>
#include <string>
#include <iostream>
#include "afxwin.h"
using namespace std;
int main(){
CString s1 = "abcd" ;
CString s2 = "xyzw" ;
CString s3 = s1+s2;
cout<<(LPCTSTR)s1<<endl<<(LPCTSTR)s3<<endl;
string s4 = (LPCTSTR)s3;
cout<<s4<<endl;
return 0;
}
下面是2个bitset合并的代码例子
#include <bitset>
#include <iostream>
#include <string>
#include <iostream>
#include "afxwin.h"
using namespace std;
int main(){
bitset<4> bits1( "1111" );
bitset<4> bits2( "0000" );
int i = bits1.size()+bits2.size();
// bitset<i> bits3; //不能使用动态参数作为模板参数,能不能想办法解决?
bitset<128> bits3;
int j=0;
for (j=0;j<bits1.size();j++)
{
if (bits1[j]==1)
bits3. set (j);
}
for (j=bits1.size();j<bits1.size()+bits2.size();j++)
{
if (bits2[j-bits1.size()]==1)
{
bits3. set (j);
}
}
cout<<bits3<<endl<<bits3.to_ulong()<<endl;
return 0;
}
bitset能够达到的最大长度
#include <bitset>
#include <vector>
#include <iostream>
#include <string>
#include <iostream>
#include "afxwin.h"
using namespace std;
int main(){
bitset<1000000> bits;// 一百万差不多到顶了,如果再加一个0,到达一千万,就会崩溃。为什么?
cout<<bits[0];
return 0;
}
想使用动态的bitset吗?
dynamic_bitset可以满足我的需求!这实在太棒了!boost万岁!ps:不知道会造成 多大的效率影响?和固定长度的代码比较起来,虽然固定一点、浪费一点空间,但是如果更快的话,也是值得了。另外:dynamic_bitset不能在 vc6下通过编译......
bit_vector
这个“位向量组”在SGI STL中实现,VC6中没有。从名字和功能介绍上就可以看出来:这是一个可以像操作vector一样方便的容器,可以push_back每一位。效率有待实验,我是在一本书上偶然看到这个库的。
然而,令我失望的是:在ubuntu和VC6下,都没有bit_vector,必须安装SGI 版本的stl才行呢。
[cpp] view
plain copy
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的二进制位的个数:
[cpp] view
plain copy
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:
[cpp] view
plain copy
size_t sz = bitvec.size(); // returns 32
[cpp] view
plain copy
// assign 1 to even numbered bits
for (int index = 0; index != 32; index += 2)
bitvec[index] = 1;
上面的循环把bitvec中的偶数下标的位都置为1。
除了用下标操作符,还可以用set、test和reset操作来测试或设置给定二进制位的值:
[cpp] view
plain copy
// equivalent loop using set operation
for (int index = 0; index != 32; index += 2)
bitvec.set(index);
为了测试某个二进制位是否为1,可以用test操作或者测试下标操作符的返回值:
[cpp] view
plain copy
if (bitvec.test(i))
// bitvec[i] is on
// equivalent test using subscript
if (bitvec[i])
// bitvec[i] is on
如果下标操作符测试的二进制位为1,则返回的测试值的结果为true,否则返回false。
[cpp] view
plain copy
bitvec.reset(); // set all the bits to 0.
bitvec.set(); // set all the bits to 1
flip操作可以对bitset对象的所有位或个别位按位取反:
[cpp] view
plain copy
bitvec.flip(0); // reverses value of first bit
bitvec[0].flip(); // also reverses the first bit
bitvec.flip(); // reverses value of all bits
[cpp] view
plain copy
unsigned long ulong = bitvec3.to_ulong();
cout << "ulong = " << ulong << endl;
to_ulong操作主要用于把bitset对象转到C风格或标准C++之前风格的程序上。如果bitset对象包含的二进制位数超过unsigned long的长度,将会产生运行时异常。
[cpp] view
plain copy
bitset<32> bitvec2(0xffff); // bits 0 ... 15 are set to 1; 16 ... 31 are 0
cout << "bitvec2: " << bitvec2 << endl;
输出结果为:
[cpp] view
plain copy
bitvec2: 00000000000000001111111111111111
plain copy
#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;
}
C++ 参考:http://www.cplusplus.com/reference/bitset/bitset/
http://happyboy200032.blog.163.com/blog/static/46903113201291252033712/
http://blog.csdn.net/e6894853/article/details/7925846
有些程序要处理二进制位的有序集,每个位可能包含的是0(关)或1(开)的值。位是用来保存一组项或条件的yes/no信息(有时也称标志)的简洁方法。标准库提供了bitset类使得处理位集合更容易一些。要使用bitset类就必须要包含相关的头文件。在本书提供的例子中,假设都使用了std::bitset的using声明:
[cpp] view
plain copy
#include <bitset>
using std::bitset;
1.bitset定义和初始化
以下列出了bitset的构造函数:[cpp] view
plain copy
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对象:
[cpp] view
plain copy
// 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对象读入位集的顺序是从右向左:[cpp] view
plain copy
string strval("1100");
bitset<32> bitvec4(strval);
bitvec4的位模式中第2和3的位置为1,其余位置都为0。如果string对象的字符个数小于bitset类型的长度,则高阶位将置为0。
string对象和bitset对象之间是反向转化的:string对象的最右边字符(即下标最大的那个字符)用来初始化bitset对象的低阶位(即下标为0的位)。当用string对象初始化bitset对象时,记住这一差别很重要。
不一定要把整个string对象都作为bitset对象的初始值。相反,可以只用某个子串作为初始值:
[cpp] view
plain copy
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对象中的单个或多个二进制位: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流 |
std::bitset是STL的一个模板类,它的参数是整形的数值,使用位的方式和数组区别不大,相当于只能存一个位的数组。下面看一个例子
[cpp] view
plain copy
bitset<20> b1(5);
cout<<"the set bits in bitset<5> b1(5) is:"
<< b1 <<endl;
结果是 the set bits in bitset<5> b1(5) is:00000000000000000101
它是以整数5传递进去,而以二进制数打印出来。
bitset还可以用作字符串转为整型
[cpp] view
plain copy
string bitval2;
cin>>bitval2;
// int length = strlen("11101101100");
// bitset<11>b2(bitval2);
bitset<11> b2(bitval2);
cout<<b2<<"is "<<b2.to_ulong()<<endl;
以及整形转为字符串
[cpp] view
plain copy
int interge1;
cin>>interge1;
cout<<"************整数转为字符串**************"<<endl;
bitset<11>b3(interge1);
cout<<b3.to_ulong()<<"is "<<b3.to_string()<<endl;
注意事项
你看得出来下面的代码为什么输出7和9吗?
#include<iostream>
#include<bitset>
using namespace std;
void main()
{
bitset<4> bit(1111);
cout<<bit.to_ulong()<<endl;
bitset<4> ait(1001);
cout<<ait.to_ulong()<<endl;
}
原因很简单:bitset调用的构造函数,1111为十进制,换成二进制为 0x10001010111,最后4位为0111,输出就是7;如果你想规定bitset里面的每一位,那么最好用string类 型:bitset<4> bits("1111"); 这样输出就是15了。
字符串合并以及输出的问题,要搞定,还真麻烦......为了偷懒,在多个类型之间转来转去的......不过写起来真的很简单,哈哈!有现成的方法就用呗!不管效率了......
#include <iostream>
#include <string>
#include <iostream>
#include "afxwin.h"
using namespace std;
int main(){
CString s1 = "abcd" ;
CString s2 = "xyzw" ;
CString s3 = s1+s2;
cout<<(LPCTSTR)s1<<endl<<(LPCTSTR)s3<<endl;
string s4 = (LPCTSTR)s3;
cout<<s4<<endl;
return 0;
}
下面是2个bitset合并的代码例子
#include <bitset>
#include <iostream>
#include <string>
#include <iostream>
#include "afxwin.h"
using namespace std;
int main(){
bitset<4> bits1( "1111" );
bitset<4> bits2( "0000" );
int i = bits1.size()+bits2.size();
// bitset<i> bits3; //不能使用动态参数作为模板参数,能不能想办法解决?
bitset<128> bits3;
int j=0;
for (j=0;j<bits1.size();j++)
{
if (bits1[j]==1)
bits3. set (j);
}
for (j=bits1.size();j<bits1.size()+bits2.size();j++)
{
if (bits2[j-bits1.size()]==1)
{
bits3. set (j);
}
}
cout<<bits3<<endl<<bits3.to_ulong()<<endl;
return 0;
}
bitset能够达到的最大长度
#include <bitset>
#include <vector>
#include <iostream>
#include <string>
#include <iostream>
#include "afxwin.h"
using namespace std;
int main(){
bitset<1000000> bits;// 一百万差不多到顶了,如果再加一个0,到达一千万,就会崩溃。为什么?
cout<<bits[0];
return 0;
}
想使用动态的bitset吗?
dynamic_bitset可以满足我的需求!这实在太棒了!boost万岁!ps:不知道会造成 多大的效率影响?和固定长度的代码比较起来,虽然固定一点、浪费一点空间,但是如果更快的话,也是值得了。另外:dynamic_bitset不能在 vc6下通过编译......
bit_vector
这个“位向量组”在SGI STL中实现,VC6中没有。从名字和功能介绍上就可以看出来:这是一个可以像操作vector一样方便的容器,可以push_back每一位。效率有待实验,我是在一本书上偶然看到这个库的。
然而,令我失望的是:在ubuntu和VC6下,都没有bit_vector,必须安装SGI 版本的stl才行呢。
2.1测试整个bitset对象
如果bitset对象中有一个或多个二进制位置为1,则any操作返回true,也就是说,其返回值等于1;相反,如果bitset对象中的二进制位全为0,则none操作返回true。[cpp] view
plain copy
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的二进制位的个数:
[cpp] view
plain copy
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:
[cpp] view
plain copy
size_t sz = bitvec.size(); // returns 32
2.2访问bitset对象中的位
可以用下标操作符来读或写某个索引位置的二进制位,同样地,也可以用下标操作符测试给定二进制位的值或设置某个二进制位的值:[cpp] view
plain copy
// assign 1 to even numbered bits
for (int index = 0; index != 32; index += 2)
bitvec[index] = 1;
上面的循环把bitvec中的偶数下标的位都置为1。
除了用下标操作符,还可以用set、test和reset操作来测试或设置给定二进制位的值:
[cpp] view
plain copy
// equivalent loop using set operation
for (int index = 0; index != 32; index += 2)
bitvec.set(index);
为了测试某个二进制位是否为1,可以用test操作或者测试下标操作符的返回值:
[cpp] view
plain copy
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:[cpp] view
plain copy
bitvec.reset(); // set all the bits to 0.
bitvec.set(); // set all the bits to 1
flip操作可以对bitset对象的所有位或个别位按位取反:
[cpp] view
plain copy
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操作:[cpp] view
plain copy
unsigned long ulong = bitvec3.to_ulong();
cout << "ulong = " << ulong << endl;
to_ulong操作主要用于把bitset对象转到C风格或标准C++之前风格的程序上。如果bitset对象包含的二进制位数超过unsigned long的长度,将会产生运行时异常。
2.5输出二进制位
可以用输出操作符输出bitset对象中的位模式:[cpp] view
plain copy
bitset<32> bitvec2(0xffff); // bits 0 ... 15 are set to 1; 16 ... 31 are 0
cout << "bitvec2: " << bitvec2 << endl;
输出结果为:
[cpp] view
plain copy
bitvec2: 00000000000000001111111111111111
2.6使用位操作符
bitset类也支持内置的位操作符。C++定义的这些操作符都只适用于整型操作数,它们所提供的操作类似于本节所介绍的bitset操作。3.程序实例
[cpp] viewplain copy
#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 <iostream> #include <bitset> #include <string> using namespace std; int main(){ //bitset<n> b;//b有n位,每位都为0 bitset<16> bitvec; cout << bitvec << endl; //bitset<n> b(u); //b是unsigned long型u的一个副本 bitset<16> bitvec2(0xffff); cout << bitvec2 << endl; bitset<128> bitvec3(0xffff); cout << bitvec3 << endl; //bitset<n> b(s); //b是string对象s中含有的位串的副本 string strval("1100"); bitset<32> bitvec4(strval); cout << bitvec4 << endl; string str("1111111000000011001101"); //bitset<n> b(s, pos, n);//b是s中从位置pos开始的n个位的副本 bitset<32> bitvec5(str, 5, 4); cout << bitvec5 << endl; bitset<32> bitvec6(str, str.size() - 4); cout << bitvec6 << endl; cout << sizeof(unsigned long) << endl; //unsigned long a = 1; //unsigned long b = a << 63; uint64_t a = 1; uint64_t b = a << 63; bitset<64> vec(b); cout << vec << endl; return 0; } output: 16 16 128 32 32 32 1 64
#include <iostream> #include <stdint.h> #include <bitset> using namespace std; int main() { for(int i=0; i<64; i++) { uint64_t a = 1; uint64_t b = a << i; bitset<64> bs(b); cout << i << " \t" << bs << "," << bs.to_ulong() << endl; } bitset<64> sum_bin; sum_bin.set(); cout << "\t" << sum_bin << "," << sum_bin.to_ulong() << endl; return 0; } 0000000000000000000000000000000000000000000000000000000000000001,1 0000000000000000000000000000000000000000000000000000000000000010,2 0000000000000000000000000000000000000000000000000000000000000100,4 0000000000000000000000000000000000000000000000000000000000001000,8 0000000000000000000000000000000000000000000000000000000000010000,16 0000000000000000000000000000000000000000000000000000000000100000,32 0000000000000000000000000000000000000000000000000000000001000000,64 0000000000000000000000000000000000000000000000000000000010000000,128 0000000000000000000000000000000000000000000000000000000100000000,256 0000000000000000000000000000000000000000000000000000001000000000,512 0000000000000000000000000000000000000000000000000000010000000000,1024 0000000000000000000000000000000000000000000000000000100000000000,2048 0000000000000000000000000000000000000000000000000001000000000000,4096 0000000000000000000000000000000000000000000000000010000000000000,8192 0000000000000000000000000000000000000000000000000100000000000000,16384 0000000000000000000000000000000000000000000000001000000000000000,32768 0000000000000000000000000000000000000000000000010000000000000000,65536 0000000000000000000000000000000000000000000000100000000000000000,131072 0000000000000000000000000000000000000000000001000000000000000000,262144 0000000000000000000000000000000000000000000010000000000000000000,524288 0000000000000000000000000000000000000000000100000000000000000000,1048576 0000000000000000000000000000000000000000001000000000000000000000,2097152 0000000000000000000000000000000000000000010000000000000000000000,4194304 0000000000000000000000000000000000000000100000000000000000000000,8388608 0000000000000000000000000000000000000001000000000000000000000000,16777216 0000000000000000000000000000000000000010000000000000000000000000,33554432 0000000000000000000000000000000000000100000000000000000000000000,67108864 0000000000000000000000000000000000001000000000000000000000000000,134217728 0000000000000000000000000000000000010000000000000000000000000000,268435456 0000000000000000000000000000000000100000000000000000000000000000,536870912 0000000000000000000000000000000001000000000000000000000000000000,1073741824 0000000000000000000000000000000010000000000000000000000000000000,2147483648 0000000000000000000000000000000100000000000000000000000000000000,4294967296 0000000000000000000000000000001000000000000000000000000000000000,8589934592 0000000000000000000000000000010000000000000000000000000000000000,17179869184 0000000000000000000000000000100000000000000000000000000000000000,34359738368 0000000000000000000000000001000000000000000000000000000000000000,68719476736 0000000000000000000000000010000000000000000000000000000000000000,137438953472 0000000000000000000000000100000000000000000000000000000000000000,274877906944 0000000000000000000000001000000000000000000000000000000000000000,549755813888 0000000000000000000000010000000000000000000000000000000000000000,1099511627776 0000000000000000000000100000000000000000000000000000000000000000,2199023255552 0000000000000000000001000000000000000000000000000000000000000000,4398046511104 0000000000000000000010000000000000000000000000000000000000000000,8796093022208 0000000000000000000100000000000000000000000000000000000000000000,17592186044416 0000000000000000001000000000000000000000000000000000000000000000,35184372088832 0000000000000000010000000000000000000000000000000000000000000000,70368744177664 0000000000000000100000000000000000000000000000000000000000000000,140737488355328 0000000000000001000000000000000000000000000000000000000000000000,281474976710656 0000000000000010000000000000000000000000000000000000000000000000,562949953421312 0000000000000100000000000000000000000000000000000000000000000000,1125899906842624 0000000000001000000000000000000000000000000000000000000000000000,2251799813685248 0000000000010000000000000000000000000000000000000000000000000000,4503599627370496 0000000000100000000000000000000000000000000000000000000000000000,9007199254740992 0000000001000000000000000000000000000000000000000000000000000000,18014398509481984 0000000010000000000000000000000000000000000000000000000000000000,36028797018963968 0000000100000000000000000000000000000000000000000000000000000000,72057594037927936 0000001000000000000000000000000000000000000000000000000000000000,144115188075855872 0000010000000000000000000000000000000000000000000000000000000000,288230376151711744 0000100000000000000000000000000000000000000000000000000000000000,576460752303423488 0001000000000000000000000000000000000000000000000000000000000000,1152921504606846976 0010000000000000000000000000000000000000000000000000000000000000,2305843009213693952 0100000000000000000000000000000000000000000000000000000000000000,4611686018427387904 1000000000000000000000000000000000000000000000000000000000000000,9223372036854775808 1111111111111111111111111111111111111111111111111111111111111111,18446744073709551615
相关文章推荐
- STL bitset用法总结
- [面试经]STL bitset用法总结
- STL bitset用法总结
- STL基本用法总结
- c++ STL的list用法总结
- c++ bitset用法总结
- C++ STL之vector用法总结
- STL中查找方法用法总结-adjacent_find, binary_search, includes, lower_bound, upper_bound, equal_range
- C++ STL之vector用法总结
- C++中STL用法总结
- C++ STL之vector用法总结
- stl.pair用法总结
- C++ STL 中的 bitset 用法
- C++ STL multimap用法总结
- STL中string类的用法总结
- STL bitset 的总结
- stl::find_if用法总结
- C++总结7——STL基本原理和用法
- C++ STL之vector用法总结
- 【STL容器-vector用法总结(1)】