Question

我正在开发一个用于卷积编码器和位打孔的软件。

因此在我的程序中，每个循环都会生成一个55位长的数据。它存储在unsigned long long类型变量的前55位中。在每次迭代之后，我必须将这55位传输到无符号字符的缓冲区（缓冲区很大，大约500字节）。这些位必须连续存储在此缓冲区中。（即没有间隙）。这样容易连接是否有点技巧？

Answer 1

编辑：我正确地指出，因为我通过uint64_t*对char缓冲区进行别名，我违反了严格的别名规则，而且我也容易受到错误的攻击由于字节顺序的差异。但是，如果您对您的平台有一定的保证，这可能仍然有效。它可以通过使用64位元素的缓冲区来解决，而不是单个字节。

如果您想要一个不依赖于任何外部库的准系统算法，您可以使用下面的代码段。请注意，bitset仅用于显示结果并确保其有效。

作为测试，我定义了一个55位模式，由54个连续的1＆＃s组成，后跟一个0. 64位值（x）中的其余9位也是零。缓冲区是一个500字节的字符数组，我将其别名为uint64_t*。该算法跟踪当前的64位块（currentBlock）和该块内的当前位（currentBit）。它执行以下操作：

移动位模式，使其从当前位位置开始。
将结果与当前的64位块进行对比。这意味着位模式的第一部分连接到当前块的剩余部分。例如，在第二次迭代中，当第一个块的前55位被填充时，剩余的9位将被占用。
更新currentBit变量。

检查currentBlock是否溢出，如果是，则移动到下一个块并连接55位模式的其余部分。

#include <iostream>
#include <bitset> // only used for testing, not for the algorithm
using namespace std;

int main()
{
    size_t nBits = 55;

    // 54 1's, followed by 10 0's
    uint64_t x = 0b1111111111111111111111111111111111111111111111111111110000000000;

    // 500 byte buffer:
    char buf8[500]{};
    uint64_t *buf = reinterpret_cast<uint64_t*>(&buf8[0]);

    // This would be better; use this if possible
    // uint64_t buf[100];

    int currentBit = 0;
    int currentBlock = 0;

    // concatenate the 55-bitpattern 10 times 
    for (int i = 0; i != 10; ++i)
    {
        buf[currentBlock] |= (x >> currentBit);

        currentBit += nBits;
        if (currentBit >= 64)
        {
            ++currentBlock;
            currentBit %= 64;

            buf[currentBlock] |= x << (nBits - currentBit);
        }
    }

    // TEST
    for (int i = 0; i != 5; ++i)
        cout << bitset<64>(buf[i]) << '\n';
}

您应该概括一下并将其封装在一个函数中。这取决于你。该程序生成以下输出：

1111111111111111111111111111111111111111111111111111110111111111
1111111111111111111111111111111111111111111110111111111111111111
1111111111111111111111111111111111110111111111111111111111111111
1111111111111111111111111110111111111111111111111111111111111111
1111111111111111110111111111111111111111111111111111111111111111

注意0到第55位的标记。

Answer 2

我不久前写了这个课，当时我需要处理比特。它也可能对你有用。这是：

#include <deque>
#include <vector>
#include <algorithm>

class bitStream {
public:
    bitStream() {}

    /// Copies the data from another bitStream into this one upon construction
    bitStream(const bitStream& bStream, bool reverse=false) {
        this->appendData(bStream, reverse);
    }

    /// Copies the data from a vector of booleans upon construction
    bitStream(const vector<bool>& vec, bool reverse=false) {
        this->appendData(vec, reverse);
    }

    /// Appends data to the stream from a uint64_t type. The lower-n bits will be appended, starting with the highest bit of those by default.
    void        appendData(uint64_t data, size_t n, bool reverse=false) {
        deque<bool> _buffer;
        n = (n>64)?64:n;
        for (int i=0; i<n; i++) {
            _oneBit tmp;
            tmp.data = data;
            _buffer.push_back(tmp.data);
            data >>= 0x1;
        }
        if (!reverse) std::reverse(_buffer.begin(), _buffer.end());
        for (const auto v: _buffer) _data.push_back(v);
    }

    /// Appends data to the stream from a C-style array of booleans
    void        appendData(bool* data, size_t n, bool reverse=false) {
        if (reverse) {
            for (int i=0; i<n; i++) this->appendBit(*(data+(n-i-1)));
        } else {
            for (int i=0; i<n; i++) this->appendBit(*(data+i));
        }
    }

    /// Appends data to the stream from a vector of booleans
    void        appendData(const vector<bool>& vec, bool reverse=false) {
        if (reverse) {
            for (auto i = vec.size()-1; vec.size() > i; --i) this->appendBit(vec.at(i));
        } else {
            for (const auto& v : vec) this->appendBit(v);
        }
    }

    /// Appends a single bit
    void        appendBit(bool bit) {
        _data.push_back(bit);
    }

    /// Appends the bits from another bitStream object to this one
    void        appendData(const bitStream& bStream, bool reverse=false) {
        if (!bStream.getSize()) return;
        if (reverse) {
            for (int i=0; i<bStream.getSize(); i++) this->appendBit(*(bStream.getData()+(bStream.getSize()-i-1)));
        } else {
            for (int i=0; i<bStream.getSize(); i++) this->appendBit(*(bStream.getData()+i));
        }
    }

    /// Returns a pointer to the begining of the data (read-only!)
    const bool* getData() const { return &_data.front(); }

    /// Reference to the bit at a specified position (assignable, but at lest n+1 elements must exist before calling!)
    bool& operator[] (size_t n) {
        if (n>_data.size()-1) throw runtime_error("Out of range!");
        return _data.at(n);
    }

    /// Fills your vector with the data chopped up into "sizeof(T)"-byte pieces.
    template <typename T>
    void        getDataAsVector(vector<T>& vec) {
        vec.clear();
        size_t oSize = sizeof(T)*8;
        T tmp = 0x0;
        for (int i=0; i<_data.size(); i++) {
            if (!(i%oSize) && i) {
                vec.push_back(tmp);
                tmp = 0x0;
            }
            tmp <<= 0x1;
            tmp |= _data[i];
        }
        vec.push_back(tmp);
    }

    /// Returns the number of bits that are stored
    size_t      getSize() const { return _data.size(); }

    /// Reverses the stored bits
    void        reverse() { std::reverse(_data.begin(), _data.end()); }
private:
    deque<bool> _data;
    struct _oneBit {
        uint8_t data:1;
    };
};

使用起来相当简单，所以我没有打算写一个例子。

首先，我从来没有真正在一个项目中使用它，因此可能存在一些错误（我记得只是非常简单地测试它），而且它没有完全完成（有一对可能的构造函数，我还没有实现）。此外，尽管名称为＆＃34; stream＆＃34;，但它与C ++中的流无关。

所以基本上它可以让你存储位。你输入的位将被存储在连续的内存地址中（是的，每个字节的内存一位，但无论如何），它在对象的生命周期内保持不变（这是因为{{ 1}}不像deque那样重新分配自己！您可以通过各种方式（从不同的数据源，以反向或非反向顺序）向其追加位，并以不同的形式将它们读回。在您的情况下，vector功能是您可以用来填充它的功能。要获取数据，如果需要，可以将appendData(uint64_t data, size_t n, bool reverse=false)填充数据切成1个字节的片段（字符）！

同样，请不要将此作为100％经过测试和工作的事情。我只是简单测试了一下，所以你应该尝试一下，看看它是否适合你！我以为我会和你分享，万一你觉得它有用。

用C ++连接比特

2 个答案: