c++ - 从 `std::vector<char>`中的位获取整数

我有一个vector<char>，我希望能够从 vector 中的各个位中获取一个无符号整数。例如。

而且我似乎无法编写正确的操作来获得所需的输出。我的预期算法如下所示:

&用(0xff >> unused bits in byte on the left)的第一个字节

<<剩下的结果输出字节数*字节中的位数

|与最终输出ojit_rli一起编码

对于每个后续字节:

(字节宽度-索引)*每字节位数

剩余的

<<

|此字节与最终输出ojit_rli

|与最终输出ojit_rli一起输出的最后一个字节(不移位)

>>通过右侧

字节中未使用的位数获得最终输出

这是我尝试对其进行编码，但未给出正确的结果:

#include <vector>
#include <iostream>
#include <cstdint>
#include <bitset>

template<class byte_type = char>
class BitValues {
    private:
    std::vector<byte_type> bytes;
    public:
        static const auto bits_per_byte = 8;
        BitValues(std::vector<byte_type> bytes) : bytes(bytes) {
        }
        template<class return_type>
        return_type get_bits(int start, int end) {
            auto byte_start = (start - (start % bits_per_byte)) / bits_per_byte;
            auto byte_end = (end - (end % bits_per_byte)) / bits_per_byte;
            auto byte_width = byte_end - byte_start;
            return_type value = 0;

            unsigned char first = bytes[byte_start];
            first &= (0xff >> start % 8);
            return_type first_wide = first;
            first_wide <<= byte_width;
            value |= first_wide;

            for(auto byte_i = byte_start + 1; byte_i <= byte_end; byte_i++) {
                auto byte_offset = (byte_width - byte_i) * bits_per_byte;
                unsigned char next_thin = bytes[byte_i];
                return_type next_byte = next_thin;
                next_byte <<= byte_offset;
                value |= next_byte;
            }
            value >>= (((byte_end + 1) * bits_per_byte) - end) % bits_per_byte;

            return value;
        }
};

int main() {
    BitValues<char> bits(std::vector<char>({'\x78', '\xDA', '\x05', '\x5F', '\x8A', '\xF1', '\x0F', '\xA0'}));
    std::cout << bits.get_bits<unsigned>(15, 29) << "\n";
    return 0;
}

(实际上:http://coliru.stacked-crooked.com/a/261d32875fcf2dc0)

我只是似乎无法将这些操作摆在头上，而且我发现调试非常困难!如果有人可以更正上面的代码，或以任何方式帮助我，将不胜感激!

编辑:

我的字节长8位

要返回的整数可能是8,16,32或64位(在

旁边)

整数存储在大端字节中

最佳答案

您犯了两个主要错误。第一个在这里:

first_wide <<= byte_width;

您应该按位计数而不是字节数进行移位。更正后的代码是:

first_wide <<= byte_width * bits_per_byte;

第二个错误是在这里:

auto byte_offset = (byte_width - byte_i) * bits_per_byte;

它应该是

auto byte_offset = (byte_end - byte_i) * bits_per_byte;

括号中的值必须是要右移的字节数，这也是byte_i远离末尾的字节数。值byte_width - byte_i没有语义(一个是增量，另一个是索引)

其余的代码很好。虽然，此算法有两个问题。

首先，当使用结果类型累加位时，您假定左侧有剩余空间。如果在右边界附近有设置的位，并且范围的选择导致这些位被移出，则不是这种情况。例如，尝试运行

bits.get_bits<uint16_t>(11, 27);

您将得到与位串00000000 00101010对应的结果42正确的结果是53290，位串11010000 00101010。请注意，最右边的4位是如何清零的。这是因为您首先要对value变量进行过度移位，从而导致这四位从变量中移出。当最后移回时，这导致位被清零。

第二个问题与最后的右移有关。如果value变量的最右位恰好在末尾右移之前为1，并且模板参数是有符号类型，则完成的右移是“算术”右移，这将导致右移。填写1的权利，您将获得不正确的负值。

例如，尝试运行:

bits.get_bits<int16_t>(5, 21);

预期结果应为6976，带有位字符串00011011 01000000，但是当前实现返回-1216以及位字符串11111011 01000000。

我将其实现放在下面，该实现从右到左构建位字符串，将位放在正确的位置开始，这样可以避免上述两个问题:

template<class ReturnType>
ReturnType get_bits(int start, int end) {
  int max_bits = kBitsPerByte * sizeof(ReturnType);
  if (end - start > max_bits) {
    start = end - max_bits;
  }

  int inclusive_end = end - 1;
  int byte_start = start / kBitsPerByte;
  int byte_end = inclusive_end / kBitsPerByte;

  // Put in the partial-byte on the right
  uint8_t first = bytes_[byte_end];
  int bit_offset = (inclusive_end % kBitsPerByte);
  first >>= 7 - bit_offset;
  bit_offset += 1;
  ReturnType ret = 0 | first;

  // Add the rest of the bytes
  for (int i = byte_end - 1; i >= byte_start; i--) {
    ReturnType tmp = (uint8_t) bytes_[i];
    tmp <<= bit_offset;
    ret |= tmp;
    bit_offset += kBitsPerByte;
  }

  // Mask out the partial byte on the left
  int shift_amt = (end - start);
  if (shift_amt < max_bits) {
    ReturnType mask = (1 << shift_amt) - 1;
    ret &= mask;
  }
}

关于c++ - 从 `std::vector<char>`中的位获取整数，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/19169753/