将成员变量复制到字节向量中

Question

我想将一个64位的成员变量逐字节复制到一个vector中。

请避免告诉我使用位操作提取每个字节然后将它们复制到向量中。

我想一行完成。

我用了memcpy和copy方法，但是都失败了。

示例代码如下：

#include <iostream>
#include <vector>
#include <cstdint>
#include <cstring>

using namespace std;

class A {
 public:
  A()
  : eight_bytes_data(0x1234567812345678) {
  }

  void Test() {
    vector<uint8_t> data_out;
    data_out.reserve(8);
    memcpy(data_out.data(),
           &eight_bytes_data,
           8);
    cerr << "[Test]" << data_out.size() << endl;
  }

  void Test2() {
    vector<uint8_t> data_out;
    data_out.reserve(8);
    copy(&eight_bytes_data,
         (&eight_bytes_data) + 8,
         back_inserter(data_out));
    cerr << "[Test2]" << data_out.size() << endl;
    for (auto value : data_out) {
      cerr << hex << value << endl;
    }
  }

 private:
  uint64_t eight_bytes_data;
};

int main() {
  A a;
  a.Test();
  a.Test2();
  return 0;
}

Answer 1

如果你想使用另一种类型结构的字节，你可以使用 char* 来操作每个字节：

void Test3()
{
    vector<uint8_t> data_out;
    char* pbyte = (char*)&eight_bytes_data;

    for(int i = 0; i < sizeof(eight_bytes_data); ++i)
    {
        data_out.push_back(pbyte[i]);
    }

    cerr << "[Test]" << data_out.size() << endl;

}

很遗憾，您要求的是单行解决方案，我认为这不可行。

Answer 2

正如其他人已经指出您出错的地方一样，有一个危险的单行解决方案。

首先你需要确保你的向量有足够的大小来接收 8 个字节。像这样：

data_out.resize(8);

您可以执行 reinterpret_cast 以强制您的编译器将向量中的这 8 个字节解释为 8 个字节的唯一类型，然后执行复制

*(reinterpret_cast<uint64_t*>(data_out.data())) = eight_bytes_data;

我无法弄清出现问题的所有可能性。所以使用风险自负。

Answer 3

如果您对更通用的版本感兴趣：

namespace detail
{
    template<typename Byte, typename T>
    struct Impl
    {
        static std::vector<Byte> impl(const T& data)
        {
                std::vector<Byte> bytes;
                bytes.resize(sizeof(T)/sizeof(Byte));
                *(T*)bytes.data() = data;
                return bytes;
        }
    };

    template<typename T>
    struct Impl<bool, T>
    {
        static std::vector<bool> impl(const T& data)
        {
            std::bitset<sizeof(T)*8> bits(data);
            std::string string = bits.to_string();
            std::vector<bool> vector;
            for(const auto& x : string)
                vector.push_back(x - '0');
            return vector;
        }
    };
}

template<typename Byte = uint8_t,
         typename T>
std::vector<Byte> data_to_bytes(const T& data)
{
    return detail::Impl<Byte,T>::impl(data);
}

int main()
{
    uint64_t test = 0x1111222233334444ull;

    for(auto x : data_to_bytes<bool>(test))
        std::cout << std::hex << uintmax_t(x) << " ";
    std::cout << std::endl << std::endl;

    for(auto x : data_to_bytes(test))
        std::cout << std::hex << uintmax_t(x) << " ";
    std::cout << std::endl << std::endl;

    for(auto x : data_to_bytes<uint16_t>(test))
        std::cout << std::hex << uintmax_t(x) << " ";
    std::cout << std::endl << std::endl;

    for(auto x : data_to_bytes<uint32_t>(test))
        std::cout << std::hex << uintmax_t(x) << " ";
    std::cout << std::endl << std::endl;

    for(auto x : data_to_bytes<uint64_t>(test))
        std::cout << std::hex << uintmax_t(x) << " ";
    std::cout << std::endl << std::endl;

}

输出：

0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 1 0 0 1 1 0 0 1 1 0 0 1 1 0 1
0 0 0 1 0 0 0 1 0 0 0 1 0 0

44 44 33 33 22 22 11 11

4444 3333 2222 1111

33334444 11112222

1111222233334444

将成员变量复制到字节向量中

copy member variable into byte vector

c++

copy

vector

memcpy

c++11