訪問記憶體中的位

我想一點一點地組裝一條訊息，然后將訊息作為無符號字符的向量處理（例如計算 CRC）

我可以使用 astd::vector<bool>或 a組合訊息 OKstd::bitset

我可以將組裝的訊息復制到 std::vector 一點一點地做。（注意：填充了 meesage 使其長度為整數位元組）

// assemble message
std::vector<bool> bitMessage;
...

// copy the bits one by one into bytes and add them to the message
std::vector<unsigned char> myMessage;

// loop over bytes
for (int kbyte = 0;
     kbyte < bitMessage.size() / 8;
     kbyte  )
{
    unsigned char byte = 0;

    // loop over bits
    for (int kbit = 0;
         kbit < 8;
         kbit  )
    {
        // add bit to byte
        byte  = bitMessage[8 * kbyte   kbit] << kbit;
    }

    // add byte to message
    myMessage.push_back(byte);
}

這有效。

但它似乎非常慢！我想用std::memcpy.

對于“正常”向量，我會做

memcpy(
  myMessage.data(),
  bitMessage.data(),
  bitMessage.size() / 8 );

或者

memcpy(
  &myMessage[0],
  &bitMessage[0],
  bitMessage.size() / 8 );

但是這兩種方法都不可能使用 avector<bool>或bitset

問題： 有沒有辦法獲得指向存盤位的記憶體的指標？

答案是：不與std::vector<bool>或std::bitset

但是，通過一些提示，尤其是來自@Ayxan Haqverdili 的提示，可以撰寫一個小類，該類將接受單個位并std::vector<unsigned char>在我們進行時構建一個有禮貌的類。

/** Build a message bit by bit, creating an unsigned character vector of integer length
 * 
 * Hides the messy bit twiddling required,
 * allowing bits to be added to the end of the message
 * 
 * The message is automatically padded at the end with zeroes
 */
class cTwiddle
{
public:
    std::vector<unsigned char> myMessage;

    cTwiddle() : myBitLength(0) {}

    /** add a bit to end of message
     * @param[in] bit 
     */
    void add(bool bit)
    {
        // check if message vector is full
        if (!(myBitLength % 8))
        {
            // add byte to end of message
            myMessage.push_back(0);
        }

        myMessage.back()  = (1 & bit) << (myBitLength % 8);
        myBitLength  ;
    }

private:
    int myBitLength;
};

uj5u.com熱心網友回復：

顯然，這些類都沒有定義布局。只需撰寫自己的類并定義所需的布局：

template <int size>
class BitSet final {
 private:
  unsigned char buffer[size / 8   (size % 8 != 0)] = {};

 public:
  constexpr bool get(size_t index) const noexcept {
    return (buffer[index / 8] >> (index % 8)) & 1U;
  }

  constexpr void set(size_t index) noexcept {
    buffer[index / 8] |= (1U << (index % 8));
  }

  constexpr void clear(size_t index) noexcept {
    buffer[index / 8] &= ~(1U << (index % 8));
  }
};

Memcpy-ing 這個類非常好。否則，您還可以提供對位元組陣列的直接訪問。

或者，您可以動態分配緩沖區：

#include <memory>

class DynBitSet final {
 private:
  size_t size = 0;
  std::unique_ptr<unsigned char[]> buffer;

 public:
  explicit DynBitSet(size_t bitsize)
      : size(bitsize / 8   (bitsize % 8 != 0)),
        buffer(new unsigned char[size]{}) {}

  bool get(size_t index) const noexcept {
    return (buffer[index / 8] >> (index % 8)) & 1U;
  }

  void set(size_t index) noexcept { buffer[index / 8] |= (1U << (index % 8)); }

  void clear(size_t index) noexcept {
    buffer[index / 8] &= ~(1U << (index % 8));
  }

  auto bitSize() const noexcept { return size * 8; }
  auto byteSize() const noexcept { return size; }
  auto const* byteBuffer() const noexcept { return buffer.get(); }
};

uj5u.com熱心網友回復：

有沒有辦法獲得指向存盤位的記憶體的指標[在 std::vector 中]？

不。這個想法是不可能的。

有沒有辦法

有趣的事實：在 glibc 中，迭代器中的成員是公共的。

#include <vector>
#include <iostream>
int main() {
    std::vector<bool> vec{1,0,1,0,1,1,1,1};
    std::cout << *vec.begin()._M_p << '\n';
}

標籤：

上一篇：C 無法實體化模板類

下一篇：從編譯時已知的字串中檢索型別