C++ 将字节数组转换为位集

我有一个由随机数生成器生成的字节数组。我想把它放到STL位集中

不幸的是，位集似乎只支持以下构造函数：

由1和0组成的字符串，如“10101011”

未签名的长字符。（我的字节数组将更长）

---

我现在能想到的唯一解决方案是逐位读取字节数组，并生成一个由1和0组成的字符串。有谁有更有效的解决方案吗？

您可以从流中初始化位集。我不记得如何将字节[]放入流中，但是

从

位集x；
库特（x）{
cout比特集有一个第三个构造函数，它不需要任何参数，将所有比特都设置为0。我想你需要使用它，然后遍历数组，为字节数组中的每个比特调用
set（）

一点蛮力，但它会工作。将每个字节内的字节索引和位偏移量转换为位集索引会有点复杂，但这不是一点思考的问题（可能是在调试器下运行）不会解决问题。我认为这很可能比通过字符串转换或流运行数组更简单、更高效。
类似的事情

#include <bitset>
#include <climits>

template<size_t numBytes>
std::bitset<numBytes * CHAR_BIT> bytesToBitset(uint8_t *data)
{
    std::bitset<numBytes * CHAR_BIT> b;

    for(int i = 0; i < numBytes; ++i)
    {
        uint8_t cur = data[i];
        int offset = i * CHAR_BIT;

        for(int bit = 0; bit < CHAR_BIT; ++bit)
        {
            b[offset] = cur & 1;
            ++offset;   // Move to next bit in b
            cur >>= 1;  // Move to next bit in array
        }
    }

    return b;
}

#包括
#包括
模板
std:：位集bytesToBitset（uint8_t*数据）
{
std：：位集b；
对于（int i=0；i>=1；//移动到数组中的下一位
}
}
返回b；
}

以及一个示例用法：

int main()
{
    std::array<uint8_t, 4> bytes = { 0xDE, 0xAD, 0xBE, 0xEF };
    auto bits = bytesToBitset<bytes.size()>(bytes.data());
    std::cout << bits << std::endl;
}

intmain（）
{
数组字节={0xDE，0xAD，0xBE，0xEF}；
自动位=bytesToBitset（bytes.data（））；
伙计们，我花了很多时间编写了一个反向函数（位集->字节/字符数组）。它是：

    bitset<SIZE> data = ...

    // bitset to char array
    char current = 0;
    int offset = 0;
    for (int i = 0; i < SIZE; ++i) {
        if (data[i]) { // if bit is true
            current |= (char)(int)pow(2, i - offset * CHAR_BIT); // set that bit to true in current masked value
        } // otherwise let it to be false
        if ((i + 1) % CHAR_BIT == 0) { // every 8 bits
            buf[offset++] = current; // save masked value to buffer & raise offset of buffer
            current = 0; // clear masked value
        }
    }

    // now we have the result in "buf" (final size of contents in buffer is "offset")

位集数据=。。。
//位集到字符数组
字符电流=0；
整数偏移=0；
对于（int i=0；i
好吧，老实说，我很无聊，开始觉得必须有一种比设置每一位稍微快一点的方法

template<int numBytes>
std::bitset<numBytes * CHARBIT bytesToBitset(byte *data)
{
    std::bitset<numBytes * CHAR_BIT> b = *data;

    for(int i = 1; i < numBytes; ++i)
    {
        b <<= CHAR_BIT;  // Move to next bit in array
        b |= data[i];    // Set the lowest CHAR_BIT bits
    }

    return b;
}

模板
std:：bitset这是我使用模板元编程的实现。

循环在编译时完成。

我采用@strager版本，对其进行了修改，以便为TMP做准备：


改变了迭代的顺序（这样我就可以从中进行递归）
使用的变量数量减少

运行时带有循环的修改版本：

template <size_t nOfBytes>
void bytesToBitsetRunTimeOptimized(uint8_t* arr, std::bitset<nOfBytes * CHAR_BIT>& result) {
  for(int i = nOfBytes - 1; i >= 0; --i) {
    for(int bit = 0; bit < CHAR_BIT; ++bit) {
      result[i * CHAR_BIT + bit] = ((arr[i] >> bit) & 1);
    }
  }
}

模板
void bytestobitsettruntimeoptimized（uint8_t*arr，std:：位集和结果）{
对于（int i=nOfBytes-1；i>=0；--i）{
用于（int位=0；位<字符位；++位）{
结果[i*CHAR\u位+位]=（（arr[i]>>位）&1）；
}
}
}

基于此的TMP版本：

template<size_t nOfBytes, int I, int BIT> struct LoopOnBIT {
  static inline void bytesToBitset(uint8_t* arr, std::bitset<nOfBytes * CHAR_BIT>& result) {
    result[I * CHAR_BIT + BIT] = ((arr[I] >> BIT) & 1);
    LoopOnBIT<nOfBytes, I, BIT+1>::bytesToBitset(arr, result);
  }
};
// stop case for LoopOnBIT
template<size_t nOfBytes, int I> struct LoopOnBIT<nOfBytes, I, CHAR_BIT> {
  static inline void bytesToBitset(uint8_t* arr, std::bitset<nOfBytes * CHAR_BIT>& result) { }
};

template<size_t nOfBytes, int I> struct LoopOnI {
  static inline void bytesToBitset(uint8_t* arr, std::bitset<nOfBytes * CHAR_BIT>& result) {
    LoopOnBIT<nOfBytes, I, 0>::bytesToBitset(arr, result);
    LoopOnI<nOfBytes, I-1>::bytesToBitset(arr, result);
  }
};
// stop case for LoopOnI
template<size_t nOfBytes> struct LoopOnI<nOfBytes, -1> {
  static inline void bytesToBitset(uint8_t* arr, std::bitset<nOfBytes * CHAR_BIT>& result) { }
};

template <size_t nOfBytes>
void bytesToBitset(uint8_t* arr, std::bitset<nOfBytes * CHAR_BIT>& result) {
  LoopOnI<nOfBytes, nOfBytes - 1>::bytesToBitset(arr, result);
}

模板结构LoopOnBIT{
静态内联void bytesToBitset（uint8_t*arr，std:：位集和结果）{
结果[I*CHAR\u位+位]=（（arr[I]>>位）&1）；
LoopOnBIT:：bytesToBitset（arr，result）；
}
};
//LoopOnBIT的停止情况
模板结构LoopOnBIT{
静态内联void bytesToBitset（uint8_t*arr，std:：bitset&result）{}
};
模板结构LoopOnI{
静态内联void bytesToBitset（uint8_t*arr，std:：位集和结果）{
LoopOnBIT:：bytesToBitset（arr，result）；
LoopOnI:：bytesToBitset（arr，result）；
}
};
//停止为LoopOnI辩护
模板结构LoopOnI{
静态内联void bytesToBitset（uint8_t*arr，std:：bitset&result）{}
};
模板
void bytesToBitset（uint8_t*arr，std:：位集和结果）{
LoopOnI:：bytesToBitset（arr，result）；
}

客户端代码：

uint8_t arr[]={0x6A};
  std::bitset<8> b; 
  bytesToBitset<1>(arr,b);

uint8_t arr[]={0x6A}；
std：：位集b；
bytesToBitset（arr，b）；

uint8_t arr[]={0x6A};
  std::bitset<8> b; 
  bytesToBitset<1>(arr,b);