将标准：：矢量<uint8_t>转换为打包标准：：矢量<uint64_t>

Question

我正在寻找一种有效的方法，没有UB将std::vector<uint8_t>转换为std::vector<uint64_t>s.tstd::vector<uint64_t>中的每个元素保存来自std::vector<uint8_t>的8个元素的信息。其余的元素应该用零填充，但这可以稍后完成。

目前为止我想到的最好的方法是:

std::vector<uint64_t> foo(std::vector<uint8_t> const & v8) {
std::vector<uint64_t> v64;
v64.reserve((v8.size() + 7) / 8);
size_t i = 0;
uint64_t tmp;
for(; i + 8 < v8.size(); i += 8) {
memcpy(&tmp, v8.data() + i, 8);
v64.push_back(tmp);
}
tmp = 0; // fill remainder with 0s.
memcpy(&tmp, v8.data() + i, v8.size() - i);
v64.push_back(tmp);
return v64;
}

但是我希望有一些更干净/更好的方法。

Edit1:关于遗漏字节顺序问题的解决方案。@VainMain指出

可以通过memcpy之后的字节交换来修复。

Answer 1

如果您打算使用range-v3库，您可以使用ranges::view::chunk(或可能很快可用的c++ 23标准库实现等效)。

这将使您从计算存储打包值所需的向量大小中解脱出来:

#include <array>
#include <cstddef>
#include <span>
#include <vector>
#include <range/v3/all.hpp>
std::vector<std::uint64_t> pack(const std::span<const std::uint8_t> values)
{
const auto chunked_view = ranges::view::chunk(values, 8);
std::vector<std::uint64_t> packed(ranges::size(chunked_view));
ranges::transform(chunked_view, packed.begin(), [](const auto& word) {
std::array<std::uint8_t, 8> buf{0}; // init with all 0's
ranges::copy(word, buf.begin());
std::uint64_t packed_word;
std::memcpy(&packed_word, buf.data(), 8);
return packed_word;
});

return packed;
}

示例(参见godbolt.org)

int main()
{
std::array<uint8_t, 9> values;
std::iota(values.begin(), values.end(), std::uint8_t{0});
for (auto t : pack(values))
std::cout << std::hex << t << std::endl;
// prints
// 706050403020100
// 8
return 0;
}