标签: std-bitset

首先,我想要一个普通的枚举而不是基于位的枚举,因为不同枚举的数量将超出任何整数类型.我也想利用C++ 11的类型安全性enum class.要做到这一点,自然的选择是std::bitset,但我不知道如何将这两者结合在一起.

需要定制bitset吗？如何绕过这样一个类的实现？

我想使用std::bitset::all但不幸的是我的编译器是早期的C++ 11.我知道我可以通过检查循环中是否设置了所有位来模仿功能std::bitset.

例如,

template<std::size_t N>
bool
all(std::bitset<N> const &bs) {
  int hits(0), sz(bs.size());
  for(int i(0); i < sz; ++i) {
    hits += bs[i];
  }
  return hits == sz;
}

问:

std::bitset::all对于过时的C++ 11编译器的替代是否比上面显示的更准确.

我正在编写一个函数,它将bitset转换为int/uint值,因为bitset可能比目标类型的位数少.

这是我写的函数:

template <typename T,size_t count> static T convertBitSetToNumber( const std::bitset<count>& bitset )
{
    T result;
    #define targetSize (sizeof( T )*CHAR_BIT)
    if ( targetSize > count )
    {
        // if bitset is 0xF00, converting it as 0x0F00 will lose sign information (0xF00 is negative, while 0x0F00 is positive)
        // This is because sign bit is on the left.
        // then, we need to add a zero (4bits) on the right and then convert 0xF000, later, we will divide by 16 …

要生成UFI编号,我使用bitset大小为74.要执行UFI生成的第2步,我需要转换此数字:

9 444 732 987 799 592 368 290
(10000000000000000000000000000101000001000001010000011101011111100010100010)

成:

DFSTTM62QN6DTV1

通过将第一个表示转换为基数31并从表中获取等效的字符.

#define PAYLOAD_SIZE 74
// payload = binary of 9444732987799592368290
std::bitset<PAYLOAD_SIZE> bs_payload(payload);
/*
perform modulo 31 to obtain:
12(D), 14(F), 24(S), 25(T), 25, 19, 6, 2, 22, 20, 6, 12, 25, 27, 1
*/    

有没有办法在不使用外部BigInteger库的情况下对我的bitset执行转换？

编辑:BigInteger即使是干杯和赫斯,我终于完成了一堂课.- 阿尔夫的解决方案就像一个魅力

我想知道为什么std::bitset::reference并std::vector<bool>::reference指定一个显式析构函数(不是编译生成的析构函数).因为,例如,boost::dynamic_bitset::reference似乎没有指定这样的析构函数.

考虑以下代码：

#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";
    stream>>bitset;
    std::cout<<"after = "<<bitset[0]<<std::endl;
    return 0;
}

g++在下编译libstdc++，结果为：

> g++ bitset_empty.cpp -o bitset_empty
> ./bitset_empty 
before = 1
after = 1

clang++在下编译libc++，结果为：

> clang++ -stdlib=libc++ bitset_empty.cpp -o bitset_empty
> ./bitset_empty 
before = 1
after = 0

哪一个是正确的？两者（因为未定义的行为）？海湾合作委员会？铛？

我有一个非常大的位集，比如 100 亿位。

我想做的是将其写入文件。但是使用.to_string()实际上冻结了我的计算机。

我想做的是迭代这些位并一次取 64 位，将其转换为 auint64然后将其写入文件。

但是我不知道如何访问位集的不同范围。我该怎么做？我是 C++ 的新手，不确定如何访问底层的 bitset::reference，所以请提供一个答案的例子。

我尝试使用指针，但没有得到我期望的结果。这是我目前正在尝试的一个例子。

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

int main()
{
    bitset<50> bit_array(302332342342342323);
    cout<<bit_array << "\n";
    bitset<50>* p;
    p = &bit_array;
    p++;
    int some_int;
    memcpy(&some_int, p , 2);
    cout << &bit_array << "\n";
    cout << &p << "\n";
    cout << some_int << "\n";

    return 0;
}

输出

10000110011010100111011101011011010101011010110011
0x7ffe8aa2b090                                                                                                                          
0x7ffe8aa2b098
17736

每次运行的最后一个数字似乎都发生了变化，这不是我所期望的。

如果我在堆栈上使用位集，我可以执行以下操作：

std::bitset<8> bset_s;
bset_s.flip(1);

std::cout << "Bitset on stack: " << bset_s << std::endl;
std::cout << "Element 1: " << bset_s[1] << std::endl;

输出：

Bitset on stack: 00000010
Element 1: 1

但是当我尝试在堆上分配位集时：

std::bitset<8> * bset;
bset = new std::bitset<8>;

bset->flip(1);


std::cout << "Bitset on heap: " << * bset << std::endl;
std::cout << "Element 1: " << bset[1] << std::endl;

输出：

Bitset on heap: 00000010
Element 1: 00000000

如果我尝试访问第二位，我会得到一个空的 Bitset 而不是“1”。我究竟做错了什么？

如何更改 所使用的整数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&)'" 

我觉得应该有一些简单的方法来做到这一点，但还没有找到任何东西。

我正在实现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 & divider;
leftKey = (permutationKey >> 28) & divider;

我试图打字bitset<56>，bitset<28>但没有用。

实现相同目的的其他方法是分别迭代和分配每个位。我想在不使用循环的情况下实现它，必须有另一种方法。

我能够用原始类型做到这一点

uint64_t key = 0b0001010101010101110110001100001110000011111100000000011111000000;
                    //00010101.01010101.11011000.11000011---|---10000011.11110000.00000111.11000000
uint32_t right = (uint32_t)key;
uint32_t left = key >> 32;

我怎么能这样分裂bitset？