从`std :: vector <char>`</char>里面的位获取整数

Question

我有一个vector<char>，我希望能够从向量中的一系列位获得无符号整数。 E.g。

我似乎无法编写正确的操作来获得所需的输出。我想要的算法是这样的：

• & (0xff >> unused bits in byte on the left)
的第一个字节
• <<结果留下输出字节数*字节中的位数
• |这与最终输出
• 对于每个后续字节：
  • <<留下（字节宽度 - 索引）*每字节位数
  • |此字节带有最终输出
• |最终输出的最后一个字节（未移位）
• >>最终输出由右侧字节中未使用的位数

这是我尝试编码，但没有给出正确的结果：

#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位wside
• 整数存储在big endian
中

Answer 1

你犯了两个主要错误。第一个是：

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没有语义含义（一个是delta，另一个是索引）

剩下的代码很好。虽然，这个算法有两个问题。

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

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;
  }
}

Answer 2

有趣的问题。对于一些系统来说，我做了类似的工作。

• 你的字符是8位宽吗？还是16？你的整数有多大？ 32或64？
• 忽略一分钟的矢量复杂性。
• 认为它只是一个位数组。
• 你有多少位？你有8 *个字符
• 您需要计算一个起始字符，要提取的位数，结束字符，那里的位数以及中间的字符数。
• 你需要按位和＆amp;对于第一个部分字符
• 你需要按位和＆amp;对于最后一个部分字符
• 你需要左移＆lt;＆lt; （或右移＆gt;＆gt;），具体取决于您从哪个订单开始
• 你的整数的结尾是什么？

在某些时候，您将计算数组的索引为bitindex / char_bit_width，您将值171作为bitindex，将8作为char_bit_width，这样您最终将计算出这些有用的值：

• 171/8 = 23 //第一个字节的位置
• 171％8 =第一个字符/字节中的3 //位
• 8 - 171％8 =最后一个字符/字节中的// //位
• sizeof（整数）= 4
• sizeof（整数）+（（171％8）> 0？1：0）//要检查多少个数组位置

需要一些装配......

Answer 3

我认为你肯定错过了一件事：你在矢量中索引位的方式与你在问题中给出的不同。即使用您概述的算法，位的顺序将类似于7 6 5 4 3 2 1 0 | 15 14 13 12 11 10 9 8 | 23 22 21 ...。坦率地说，我没有阅读你的整个算法，但是在第一步中错过了这个算法。