使用std::bitset计算有限集的子集
std::bitset是C++标准库中的一个类，用于表示固定大小的位集合。它提供了一种高效的方式来处理位操作，特别适用于计算有限集的子集。
有限集是指元素个数有限的集合，而子集是指包含在原集合中的一部分元素的集合。
使用std::bitset计算有限集的子集，可以按照以下步骤进行：
- 创建一个std::bitset对象，并指定其大小为原集合的大小。例如，如果原集合有n个元素，则创建一个大小为n的std::bitset对象。
- 将std::bitset对象的每个位与原集合的元素进行映射。例如，假设原集合的元素是从0到n-1的连续整数，可以将std::bitset对象的第i位与原集合的第i个元素进行映射。
- 遍历std::bitset对象的所有可能的子集。可以使用循环来遍历std::bitset对象的每个位，并根据位的状态确定子集的元素。
下面是一个示例代码，演示如何使用std::bitset计算有限集的子集：
#include <iostream>
#include <bitset>
int main() {
int n = 4; // 原集合的大小
std::bitset<4> set; // 创建一个大小为4的std::bitset对象
// 遍历std::bitset对象的所有可能的子集
for (int i = 0; i < (1 << n); i++) {
set = i; // 将std::bitset对象设置为当前子集的位表示
// 输出当前子集的元素
std::cout << "Subset: ";
for (int j = 0; j < n; j++) {
if (set[j]) {
std::cout << j << " ";
}
}
std::cout << std::endl;
}
return 0;
}这段代码使用了一个大小为4的std::bitset对象来计算一个有4个元素的集合的所有子集。它通过遍历std::bitset对象的所有可能的位表示来生成子集，并输出每个子集的元素。
使用std::bitset计算有限集的子集的优势在于其高效的位操作和内存占用。它可以快速地进行位运算，而且由于其固定大小的特性，内存占用也是可控的。
应用场景：
- 组合优化问题：可以使用std::bitset来表示一个组合，并通过遍历所有可能的子集来解决组合优化问题。
- 排列组合问题：可以使用std::bitset来生成所有可能的排列组合。
推荐的腾讯云相关产品和产品介绍链接地址：
- 腾讯云计算服务：https://cloud.tencent.com/product
- 腾讯云数据库：https://cloud.tencent.com/product/cdb
- 腾讯云服务器：https://cloud.tencent.com/product/cvm
- 腾讯云云原生服务：https://cloud.tencent.com/product/tke
- 腾讯云存储服务：https://cloud.tencent.com/product/cos
- 腾讯云区块链服务：https://cloud.tencent.com/product/baas
- 腾讯云人工智能服务：https://cloud.tencent.com/product/ai
- 腾讯云物联网服务：https://cloud.tencent.com/product/iot
- 腾讯云移动开发服务：https://cloud.tencent.com/product/mss
- 腾讯云音视频服务：https://cloud.tencent.com/product/vod
- 腾讯云网络安全服务：https://cloud.tencent.com/product/ddos
相关·内容
1回答
我正在尝试异或拖128位位集。
#include<iostream>
#include<bitset>
int main()
{
std::bitset<128> testing;
testing = std::bitset<128>(0x544F4E20776E69546F656E772020656F) ^
std::bitset<128>(0x5473206768204B20616D754674796E75);
std::cout<<testing;
}
我得到的输出是
前64位是0，最后64位
浏览 0提问于2015-10-20得票数 6
回答已采纳
1回答
我使用std::bitset给出一个数字的二进制表示。我现在只想使用二进制表示将它输出到std::cout --我不想要std::bitset的ASCII表示--我只是想输出我的位集，因为它在内存中。
bitset<32> bits = a;
cout << bits; //produces the ASCII characters for '1' and '0' depending on a
浏览 3提问于2014-09-30得票数 0
4回答
在我的程序中，我需要检查是否已经在2.5*10^9的集合中生成了一个值。我希望生成该集合的大约一半的值，并且需要有一种快速的方法来检查和更新它。位集在我看来是一个好主意，因为它不需要太多内存(每个值1位)，而且速度很快。
问题是，当我在我的类中定义我的set时，我得到了一个segmentation fault，因为它太大了(它适用于较小的尺寸)。
private:
std::bitset<2500000000UL> cover; // not working
std::bitset<25000UL> cover; // working
有什么想法吗？
谢谢
PS
浏览 0提问于2011-04-25得票数 16
回答已采纳
我尝试使用dynamic_bitset对象的set，但在运行时得到断言失败：
a.out: boost/dynamic_bitset/dynamic_bitset.hpp:1291:
bool boost::operator<(const boost::dynamic_bitset<Block, Allocator>&,
const boost::dynamic_bitset<Block, Allocator>&)
[with Block = long unsigned int,
浏览 6提问于2012-12-29得票数 2
回答已采纳
我正在尝试编写代码，用一个条件从集合生成所有子集，比如，如果我有阈值=2，那么三个子集：
1, 2, 3, 4, 5
1,3,5
1,3,4
然后程序将输出：
第一次迭代时的生成集：
1 = number of frequency = 3
2 = number of frequency = 1
3 = number of frequency = 3
4 = number of frequency = 2
5= number of frequency = 2
由于数字2<阈值的频率，我将排除这个集合的任何进一步的超集，
第二次迭代的生成集
1,3 = number of frequency
浏览 5提问于2014-05-27得票数 5
回答已采纳
1回答
有人知道位集的哈希函数使用的是什么算法吗，
这是来自网站：
#include <iostream>
#include <bitset>
#include <functional>
int main()
{
std::bitset<4> b1(1);
std::bitset<4> b2(2);
std::bitset<4> b3(b2);
std::bitset<4> b4(8);
std::cout<<b4<<'\n';
浏览 5提问于2017-05-13得票数 6
回答已采纳
5回答
我正尝试在C++中创建一个bitset作为关键字的map。但是，编译器会生成以下错误消息
In file included from /usr/include/c++/4.6/string:50:0,
from /usr/include/c++/4.6/bits/locale_classes.h:42,
from /usr/include/c++/4.6/bits/ios_base.h:43,
from /usr/include/c++/4.6/ios:43,
浏览 2提问于2012-03-14得票数 7
回答已采纳
2回答
我有一个大量使用STL的bitset的程序。gperftools显示，性能瓶颈之一是std::_Base_bitset::_S_maskbit (内联)。
从这里看起来访问或修改bitset的掩码总是被重新计算。这让我想知道查找表是否会有所帮助。
我试图实现我自己的bitset版本，其中使用了掩码查找表。但是，因为我的版本没有使用像__builtin_memcpy这样的gcc内置指令，所以它实际上比STL bitset慢得多。
所以我想知道是否有一种方法可以取代std::_Base_bitset::_S_maskbit，或者我应该通过复制STL bitset的代码并添加一个查找表来编写我自己的
浏览 0提问于2014-10-02得票数 2
2回答
如何从C++中的函数返回位集？
bitset<32>* check() {
bitset<32> v8;
for (int i = 0; i <= 5; i++) {
v8[i] = 1;
}
return v8;
}
我得到了这个错误：
[Error] cannot convert 'std::bitset<32u>' to std::bitset<32u>*' in return
浏览 12提问于2017-03-06得票数 0
回答已采纳
2回答
我使用std::bitset<CHAR_BIT> binary('c');将字符转换为二进制，但这不适用于字符串，
std::string str = "MyString";
std::bitset<SIZE_OF_STRING_IN_BITS> binary(str); //Error Exception
应该有什么替代方案呢？
浏览 0提问于2010-08-16得票数 2
回答已采纳
我有一个std::bitset，但是现在我想在上面使用一个STL算法。
我本来可以使用std::vector<bool>，但我喜欢std::bitset的构造函数，我想要std::bitset的位操作。
我是否需要遍历一个循环并将所有内容都填充到std::vector<bool>中才能使用STL算法，然后将其复制回std::bitset，还是有更好的方法？
浏览 4提问于2015-01-07得票数 9
回答已采纳
我正在开发一个应用程序，它显示了用户输入的表单。该表单有N个部分，每个部分有X个单选按钮。提供了有效选择的子集，以便当用户跨区段工作时，基于形成有效子集的可能性来启用/禁用其他区段中的按钮。
例如:第1节有用于选择A、B和C的单选按钮第2节有用于选择1、2、3和4的按钮第3节有用于选择x、y和z的按钮
有效子集是({A,2，z}，{B}，{B,1，x}，{C,4}用户可以从任何部分开始选择，但我必须根据选择动态禁用按钮。
对于上面的示例，如果用户从2开始，我将只启用A和z(也将启用2)。我不能使用trie，因为它假定前缀匹配的输入顺序。有没有我可以使用的数据结构？
浏览 3提问于2014-08-05得票数 2
假设我想改变std::bitset输出其位的默认方式。通常的做法是：
#include <iostream>
#include <bitset>
int main() {
std::cout << "size of int is: " << (sizeof (int)) << std::endl;
std::bitset<32> bits = 0xFFFF0000;
std::cout << "Original\n" << bits &l
浏览 2提问于2022-07-27得票数 3
回答已采纳
我正在寻找一种简单的方法来将二进制字符串从小端表示转换为大端表示。我正在使用bitset并找到翻转\重置\设置位的方法，但我正在寻找一种简单地颠倒它们的顺序的方法。我已经尝试了几个帖子，但没有成功。有人能帮上忙吗？
for (unsigned long i = 0; i < match.size(); ++i) {
std::bitset<16> b(i);
std::bitset<16> b_reversed = ~b;
std::cout << i << '
浏览 0提问于2016-02-04得票数 2
1回答
我在做一个机器模拟程序。我有一个主内存位集向量，这样我就可以使用指向这个向量的指针pMemory->at(i)来访问任何特定的"word“。我真的很喜欢位图向量的设计，而且我坚持它(这个程序是在.大约6个小时，呵呵！)
我在试图弄清楚如何从不同的位置(模拟寄存器和其他内存位置等)获取位集时遇到了一些困难，所以我已经阅读了一些关于使用流的内容。我想出了这个：
#include <bitset>
#include <iostream>
#include <sstream>
#include <string>
using namespa
浏览 13提问于2012-03-15得票数 5
回答已采纳
连接两个位集的最佳方式是什么？
举个例子，我有
boost::dynamic_bitset<> test1( std::string("1111") );
boost::dynamic_bitset<> test2( std::string("00") );
它们应该连接到一个三位集test3中，然后保存
111100
解决方案应该使用boost::dynamic_bitset。如果解决方案可以与std::bitset一起使用，那就更好了。在连接比特时，应该关注性能。
更新:我比较了两种方法(我和尼尔的字符串方法和信使的UPDATE方法
浏览 0提问于2010-06-17得票数 10
回答已采纳
3回答
当我用，
std::bitset<5> op1 (std::string("01001"));
std::bitset<5> op2 (std::string("10011"));
std::cout << (op1|=op2) << std::endl;
很明显一切都很好。
但我的问题是，如何使用两个不同大小的'std::bitset's来使用OR操作呢?例如，
std::bitset<11> op1 (std::string("101110011"
浏览 5提问于2014-06-22得票数 4
回答已采纳
如果我有一个std::bitset<16>，我如何将它转换成高位填充为0的std::bitset<32>？ std::bitset<16> a = 0xFF00;
std::bitset<32> b = a; // error
浏览 31提问于2019-06-10得票数 3
回答已采纳
我在我的程序中使用了std::bitset<N>，需要找到最低有效的设置位，并进行如下简单的计算：
int num = 5;
int res = num & (-num);
然后在res中设置num的最低有效位，其余的都是0的，这是因为-5用2的补码表示法。
但是我发现std::bitset<N>对于一元operator -没有任何操作符重载，这将为我提供底层位的2的补码。有没有一种简单的方法可以用std::bitset<N>实现2的补码？我总是可以使用operator ~来翻转这些位，并循环它们，从LSB到MSB进行求和和进位，但我正在寻找一个可以
浏览 0提问于2013-03-10得票数 5
回答已采纳
我在我的程序中使用了std::bitset<9> deck。默认情况下，它将所有位初始化为0。
在我的代码中的某个地方，我正在执行：deck.flip(index)，其中index可以是0-8 (位集索引)中的任何数字。
现在我需要的是找到设置为true的last位的索引。
例如：
000100010 - bitset
876543210 - index
在此示例中，设置为true的最新位位于索引5处。这就是我希望使用std::bitset找到的东西。
我已经阅读了文档，但发现没有有用的函数来做这件事，作为一个初学者，我很难弄清楚，我该怎么做呢？
(抱歉，如果问题写得不好，英语是我
浏览 41提问于2019-10-26得票数 3
回答已采纳
我有一个类型为C++的std::vector<std::bitset<128> >变量，它是在C++类中定义和填充的(这是从std::vector<std::bitset<128> >类调用的)。
我想将这个对象存储在一个NSDictionary中-或者类似于。我显然不能简单地将std::vector<std::bitset<128> >添加到NSDictionary中，因为它不是id类型的。
因此，我的问题是:如何实现相同的概念？，如何将存储在各种类型的字典中？--我能以某种方式将向量对象包装成id类型吗？即使它不是一本
浏览 2提问于2014-01-31得票数 5
4回答
如何更改bitset使用的整数？假设我使用bitset来声明一个变量mybitset，它存储一个数字的位，比如说32。在做了一些操作之后，我希望mybitset存储其他数字的位数，比如63。我怎样才能做到这一点？
我在下面添加了一小部分示例代码以帮助解释。
bitset<32> mybits(32);
....
mybits(63); // gives compilation error here, stating "no match for call to '(std::bitset<32u>) (uint&)'"
我觉得应
浏览 8提问于2015-08-25得票数 4
回答已采纳
我读了的问题，然后想，嘿，这不管用，我已经试过了。但后来我开始尝试，很快我就发现：
#include <bitset>
#include <iostream>
int main()
{
std::bitset<31> b31(-1);
std::bitset<32> b32(-1);
std::cout<<static_cast<int>(b31.to_ulong())<<std::endl;
std::cout<<static_cast<int>(b32.to_
浏览 3提问于2014-12-09得票数 4
回答已采纳
1回答
我读了中的float，然后尝试打印他的比特。我使用了std::bitset并返回与我预期不同的其他位(我知道，因为我在链接中使用了相同数量的示例)，然后我使用memcpy()将浮动的内存复制到每个1字节的4部分，然后打印，这个方法成功了，但我有4个问题。
1)为什么在浮点数中使用位集，这只打印整数部分？
2)为什么位集只与数组一起工作，而不与浮点数一起工作？
3) memcpy()按正确的顺序工作？
最后一个问题是因为0.15625f == 0b00111110001000000000000000000000。
那么我认为正确的顺序是：
bb[0] == 0b00111110;
bb[1] =
浏览 4提问于2019-11-27得票数 0
回答已采纳
3回答
通过模板的无符号整型的C++限制
、、、、
我使用一个模板将整型类型转换为二进制值的字符串表示形式。我使用了以下代码：
template<typename T>
std::string ToBinary(const T& value)
{
const std::bitset<std::numeric_limits<T>::digits + 1> bs(value);
const std::string s(bs.to_string());
return s;
}
它适用于int，但不能使用unsigned int进行编译：
unsigned int buffer_u[
浏览 0提问于2012-01-25得票数 6
回答已采纳
我想分配一个大对象(一个bitset<1000000000>)。由于要避免拥有原始指针，我尝试了以下声明：
auto foo()->std::unique_ptr<std::bitset<MAX>>;
...
{
auto bar = foo();
}
它会产生堆栈溢出错误(编译器是VS2013)。但
auto foo()->std::bitset<MAX>*;
...
{
auto bar = foo();
...
delete bar;
}
不会的。
foo()的实现如下所示：
auto is_pr
浏览 6提问于2014-12-07得票数 3
回答已采纳
7回答
与无符号整数表示的比较相对应的<操作符实现std::bitset最优化的方法是什么(它应该适用于more than 64 bits的位集)？
一个微不足道的实现是：
template<std::size_t N>
bool operator<(const std::bitset<N>& x, const std::bitset<N>& y)
{
for (int i = N-1; i >= 0; i--) {
if (x[i] && !y[i]) return false;
浏览 4提问于2014-01-20得票数 17
回答已采纳
我正在尝试将文本文件读取到std：：bitset对象的向量中。该文件由1和空格组成(用于指示0或false)，我试图通过重载输入operator>>和使用istream_iterators来实现这一点。我首先将字符串中的空格更改为0，然后构造一个用该字符串推送到向量的位。但是，当我打印时，输出看起来非常奇怪，而且似乎读取的元素比文件中的行多(位集的向量比行数长)。代码如下：
template<long unsigned int N>
std::istream& operator>>(std::istream& is, std::bit
浏览 22提问于2022-03-15得票数 1
回答已采纳
我是新来的。我有一个在lambda函数中使用dynamic_bitset的程序。在我试着运行这个程序之后，我收到了这条消息。即使没有初始化bitset的函数和处理它的函数，也会出现此消息。
有人知道这条消息的意思吗?有什么问题吗？
信息：
/usr/include/boost/dynamic_bitset/dynamic_bitset.hpp:616：boost::dynamic_bitset<Block, Allocator>::~dynamic_bitset() [with Block = long unsigned int, Allocator = std::allocato
浏览 12提问于2011-08-11得票数 2
回答已采纳
我想在C/C++中建模一个状态寄存器，它应该可以作为和访问。因此，我将它们合并如下：
#include <bitset>
#include <iostream>
union byte {
std::uint8_t uint;
std::bitset<8> bitset;
};
int main(int, char*[])
{
byte b = { .uint = 0b10101010 };
std::cout << "Value of bit 5: "
浏览 0提问于2018-09-10得票数 0
回答已采纳
2回答
使用STD位集。我正在将sting转换为二进制。如果我这样做，它就会起作用
string myString = "Hi";
for ( int i = 0; i < myString.size(); ++i)
{
cout << bitset<8>(myString.c_str()[i]) << endl;
}
如果我这样做，它就会起作用
string myString = "Hi";
for ( int i = 0; i < myString.size(); ++i)
{
cout <<
浏览 1提问于2018-01-09得票数 2
回答已采纳
3回答
#include<bits/stdc++.h>
using namespace std;
int main(){
bitset<5> num=01000;
bitset<5> n=00000;
bitset<5> result;
result=(n|num);
cout<<result;
}
答案应该是1000，但它显示了00000。
浏览 5提问于2017-08-25得票数 0
回答已采纳
4回答
假设我有3个bool类型值
bool canwalk=true;
bool cantalk=false;
bool caneat=false;
我想设置一个bitset来表示这三个
std::bitset<3> foo;
如何使用布尔值构造bitset？我想做这样的事
std::bitset<3> foo(canWalk,cantalk,caneat); //giving me 100
浏览 0提问于2017-12-13得票数 3
回答已采纳
2回答
我试图在向量中生成字符串的所有排列。例如，对于
vector<string> vs = { "a", "b", "c"};
我编写了以下代码：
do{
for (string s : vs)
cout << s << " ";
cout << endl;
} while (std::next_permutation(vs.begin(), vs.end()));
我的产出是：
A、b、c
A、c、b
B、a、c
B、c、a
C a b
C、b、a
浏览 0提问于2019-06-26得票数 1
回答已采纳
我在试着写一个程序，把一个数字转换成二进制。
代码：
#include<iostream>
#include<algorithm>
#include<bitset>
using namespace std;
int main()
{
int a;
string k;
bitset<CHAR_BIT> n;
cin>>a;
n=bitset<CHAR_BIT>(a);
cout<
浏览 0提问于2010-09-01得票数 0
回答已采纳
1回答
我正在尝试创建一个函数，该函数将返回给定内存块的N位数，并可以选择跳过M位。
示例：
unsigned char *data = malloc(3);
data[0] = 'A'; data[1] = 'B'; data[2] = 'C';
read(data, 8, 4);
跳过12位，然后从数据块"ABC“中读取8位。
“跳过”位意味着它实际上会移动整个数组，将位从右转到左。
在本例中，ABC是
01000001 01000010 01000011
函数将需要返回
0001 0100
这个问题是的后续问题。
#include
浏览 2提问于2015-09-11得票数 2
回答已采纳
2回答
从一个bitset<64>构造一个uint64_t很容易
uint64_t flags = ...;
std::bitset<64> bs{flags};
但是，是否有一种从bitset<64 * N>构建uint64_t[N]的好方法，比如flags[0]会引用最低的64位呢？
uint64_t flags[3];
// ... some assignments
std::bitset<192> bs{flags}; // this very unhelpfully compiles
浏览 3提问于2015-04-27得票数 11
回答已采纳
我有一个
std::map<int, std::bitset<256 > > m;
在构建之后，不会插入任何新的键，也不会移除任何键。我能否安全地在一个线程中分配位集，同时在其他线程中读取它而不使用互斥对象？
// thread 1:
std::bitset<256> a = getBitset();
m[1] = a;
// thread 2:
std::bitset<256> b = m[1];
// or alternatively
std::bitset<256> c = m.at(1);
我认为程序不会崩溃，但是
浏览 6提问于2022-04-29得票数 0
回答已采纳
1回答
我使用的是以下列方式创建的位集
std::bitset<4> bitset;
我想知道，如果我有带有A=0,B=1,C=1,D=0值的int，那么如何将值赋值给位集？
我读到过我能做到的
bitset.set(0, false);
bitset.set(1, true);
bitset.set(2, true);
bitset.set(3, false);
我想知道是否有更快的方法来解决这个问题？最好是一份声明？
浏览 2提问于2016-10-19得票数 0
回答已采纳
考虑以下代码：
#include <bitset>
#include <sstream>
#include <iostream>
int main(int argc, char* argv[])
{
std::stringstream stream;
std::bitset<1> bitset(1);
std::cout<<"before = "<<bitset[0]<<std::endl;
stream<<"4";
stre
浏览 2提问于2016-11-23得票数 5
回答已采纳
6回答
std::bitset有一个to_string()方法，用于序列化为1s和0s的char-based字符串。很明显，这对位集中的每一个位都使用了一个8位char，使得序列化的表示比需要的时间长8倍。
我希望将位集存储在二进制表示中，以节省空间。只有当位集中的位数少于32位时，to_ulong()方法才是相关的。我有上百个。
我不确定我是否希望在对象(地址)本身上使用memcpy()/std::copy()，因为这假设对象是POD。
API似乎没有提供我可以从中获取地址的内部数组表示的句柄。
我还想选择从二进制表示中反序列化位集。
我该怎么做？
浏览 0提问于2011-03-09得票数 16
回答已采纳
2回答
我有一节课
template <class MAX>
class A
{
std::bitset<MAX> _mem ;
}
这个类的目的是让我拥有可变长度的位集。在我的程序的不同部分中使用。
但是clang complete给出了这个错误
template argument for non type template parameter should be an expression
浏览 1提问于2015-11-18得票数 1
1回答
是否有一种将uint8_t数组转换为位集的快速方法。
uint8_t test[16];
// Call a function which populates test[16] with 128 bits
function_call(& test);
for(int i=0; i<16; i++)
cout<<test[0]; // outputs a byte
cout<<endl;
std:: bitset<128> bsTest;
我试过了，但不起作用
bsTest(test);
浏览 1提问于2016-05-04得票数 1
回答已采纳
1回答
因此，我试图为我的一个项目创建一个基类，其中一个项目将继承几个类。我的问题是，我试图从其中一个方法返回一个std::bitset，问题是每个子类中的每个子类都会返回不同大小的位集，所以我正在寻找一种方法来声明一个方法，该方法返回一个大小未知的位集，这对于子类所知的基类来说是完全未知的。此外，我还保证基类是抽象的，不会单独使用。
浏览 2提问于2012-06-01得票数 0
6回答
我想在C++中创建一个位集。我做了一点研究。我找到的所有示例都是这样的：
bitset<6> myBitset;
// do something with it
但是当我在我的类中定义变量时，我不知道位集的大小：
#include <bitset>
class Test
{
public:
std::bitset *myBitset;
}
这不能编译...
像这样初始化也不起作用：
int size = getDependentSizeForBitset();
myBitset = new bitset<size>();
浏览 0提问于2010-06-29得票数 32
回答已采纳
3回答
我想将std::bitset<64>转换为std::string。
以下是我尝试过的：
std::string bitsetToChar(std::bitset<64> bitset){
std::bitset<8> bit;
for(int i=0;i<8;i++){
for(int j=0;j<8;j++){
bit[j] = bitset[i*8+j];
}
// new char c using above bits
// link chars
}
}
结果应该是一个由8个字符组成
浏览 9提问于2017-05-11得票数 3
回答已采纳
有以下代码：
#include <iostream>
#include <bitset>
#include <limits>
#include <limits.h>
using namespace std;
constexpr std::size_t maxBits = CHAR_BIT * sizeof(std::size_t);
int main() {
std::size_t value =47;
unsigned int begin=0;
unsigned int end=32;
//std::siz
浏览 2提问于2017-09-29得票数 0
回答已采纳
我最近遇到了位集模板，我真的很想在我当前的项目中使用它们。继续阅读，我发现std::bitset模板必须具有在编译时确定的大小。许多人建议使用boost::dynamic_bitset来减轻这一要求。
为了比较这两种方法，我决定对set、flip和count方法进行速度比较。
结果是非常odd...and的，我想知道是否有人能为我解释一下。
代码在文章的末尾，但我会在这里解释我在做什么。我有一个std::bitset对象(称为bs)和一个boost::dynamic_bitset对象(称为dynbs)。每个都有n=1000000位。对于上面给定的方法，在每个n位上顺序调用该方法，并重复此R=1
浏览 50提问于2014-08-20得票数 13
回答已采纳
2回答
我正在实现DES算法，我需要将std::bitset<56> permutationKey分成两半。
std::bitset<56> permutationKey(0x133457799BBCDF);
std::bitset<28> leftKey;
std::bitset<28> rightKey;
std::bitset<56> divider(0b00000000000000000000000000001111111111111111111111111111);
rightKey = permutationKey &
浏览 0提问于2016-04-03得票数 5
回答已采纳
以下代码未编译。
#include <bitset>
#include <iostream>
class Bits
{
public:
std::bitset<4> bits;
public:
Bits();
Bits(Bits & b);
Bits & operator = (Bits & b);
bool operator [] (int index) const; // For reading
bool & operator [] (int index);
浏览 2提问于2015-07-28得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
