移动字节数组和跳过位

Question

我正在尝试制作一个函数，该函数将 return N 给定内存块的位数，并可选择跳过 M 位。

示例：

unsigned char *data = malloc(3);
data[0] = 'A'; data[1] = 'B'; data[2] = 'C';
read(data, 8, 4);

会跳过 12 位，然后从数据块 "ABC".

中读取 8 位

"Skipping" bits 意味着它实际上会将整个数组进行位移，从右到左携带位。

在这个例子中 ABC 是

01000001 01000010 01000011

并且函数需要 return

    0001 0100

此问题是 my previous question

的跟进

Minimal compilable code

#include <ios>
#include <cmath>
#include <bitset>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>

using namespace std;

typedef unsigned char byte;
typedef struct bit_data {
    byte *data;
    size_t length;
} bit_data;

/*
   Asume skip_n_bits will be 0 >= skip_n_bits <= 8
*/
bit_data *read(size_t n_bits, size_t skip_n_bits) {
    bit_data *bits = (bit_data *) malloc(sizeof(struct bit_data));

    size_t bytes_to_read = ceil(n_bits / 8.0);
    size_t bytes_to_read_with_skip = ceil(n_bits / 8.0) + ceil(skip_n_bits / 8.0);

    bits->data = (byte *) calloc(1, bytes_to_read);
    bits->length = n_bits;

    /* Hardcoded for the sake of this example*/
    byte *tmp = (byte *) malloc(3);
    tmp[0] = 'A'; tmp[1] = 'B'; tmp[2] = 'C';

    /*not working*/
    if(skip_n_bits > 0){
        unsigned char *tmp2 = (unsigned char *) calloc(1, bytes_to_read_with_skip);
        size_t i;

        for(i = bytes_to_read_with_skip - 1; i > 0; i--) {
            tmp2[i] = tmp[i] << skip_n_bits;
            tmp2[i - 1] = (tmp[i - 1] << skip_n_bits) | (tmp[i] >> (8 - skip_n_bits));
        }

        memcpy(bits->data, tmp2, bytes_to_read);
        free(tmp2);
    }else{
        memcpy(bits->data, tmp, bytes_to_read);
    }
    free(tmp);

    return bits;
}

int main(void) {
    //Reading "ABC"
    //01000001 01000010 01000011
    bit_data *res = read(8, 4);

    cout << bitset<8>(*res->data);
    cout << " -> Should be '00010100'";

    return 0;
}

当前代码 returns 00000000 而不是 00010100。我觉得错误很小，但我想念它。问题出在哪里？

Answer 1

您的代码被标记为 C++，实际上您已经在使用 bitset 等 C++ 结构，但它非常像 C。我认为要做的第一件事是使用更多的 C++。

原来 bitset 已经非常灵活了。我的方法是创建一个来存储我们输入数据中的所有位，然后根据您希望跳过的数字获取其中的一个子集，return 子集：

template<size_t N, size_t M, typename T = unsigned char>
std::bitset<N> read(size_t skip_n_bits, const std::array<T, M>& data)
{
    const size_t numBits = sizeof(T) * 8;

    std::bitset<N> toReturn; // initially all zeros

    // if we want to skip all bits, return all zeros
    if (M*numBits <= skip_n_bits)
        return toReturn;

    // create a bitset to store all the bits represented in our data array
    std::bitset<M*numBits> tmp;

    // set bits in tmp based on data
    // convert T into bit representations
    size_t pos = M*numBits-1;
    for (const T& element : data)
    {
        for (size_t i=0; i < numBits; ++i)
        {
            tmp.set(pos-i, (1 << (numBits - i-1)) & element);
        }
        pos -= numBits;
    }

    // grab just the bits we need
    size_t startBit = tmp.size()-skip_n_bits-1;
    for (size_t i = 0; i < N; ++i)
    {
        toReturn[N-i-1] = tmp[startBit];
        tmp <<= 1;
    }

    return toReturn;
}

Full working demo

现在我们可以这样称呼它了：

// return 8-bit bitset, skip 12 bits
std::array<unsigned char, 3> data{{'A', 'B', 'C'}};
auto&& returned = read<8>(12, data);
std::cout << returned << std::endl;

版画

00100100

这正是我们的输入 01000001 01000010 01000011 跳过前十二位（从左到右），只抓取接下来的 8 个可用。

我认为这比您所拥有的更容易阅读，尤其是。从 C++ 程序员的角度来看。

移动字节数组和跳过位

Shifting arrays of bytes and skipping bits

c++

arrays

bit-shift