函数获取参数的变量列表并将它们转换为一系列字节？

Question

我想创建一个函数，比如pack()，它接受一个可变参数列表并将它们转换为一系列字节，例如std::vector。

给定char c = 0x10, int x = 4, char *s = "AAA"，然后是pack()，应该表现得像：

pack(c, x, s) = 0x10, 0x04, 0x00, 0x00, 0x00, 0x41, 0x41, 0x41.

（这里我假设小端字节序）

我将如何编写这样的功能？

我一直在考虑 C 的 va_list 或 C++ 的模板机制，但我无法实现。

编写此类功能的“最佳”方式是什么？任何代码 sn-ps 演示了一种合适的技术？

Answer 1

你可以这样做：

void pack_in_vector(std::vector<std::uint8_t>& v, char c)
{
    v.push_back(c);
}

void pack_in_vector(std::vector<std::uint8_t>& v, int n)
{
    v.push_back(n & 0xFF);
    v.push_back((n >> 8) & 0xFF);
    v.push_back((n >> 16) & 0xFF);
    v.push_back((n >> 24) & 0xFF);
}

void pack_in_vector(std::vector<std::uint8_t>& v, const std::string& s)
{
    for (c : s) {
        v.push_back(c);    
    }
}

template <typename ... Ts>
std::vector<std::uint8_t> pack(const Ts&... args)
{
    std::vector<std::uint8_t> bytes;
    (pack_in_vector(bytes, args), ...); // Folding expression requires C++17
    return bytes;
}

对于 C++11，您必须将最后一个函数修改为：

template <typename ... Ts>
std::vector<std::uint8_t> pack(const Ts&... args)
{
    std::vector<std::uint8_t> bytes;

    int dummy[] = {0, (pack_in_vector(bytes, args), 0)...};
    static_cast<void>(dummy); // avoid warning for unused variable
    return bytes;
}

Answer 2

template<class F>
void range_to_bytes( F&& f, char const* begin, char const* end ){
  for(auto*it=begin; it != end; ++it)
    f(*it);
}
template<class F>
void to_bytes( F&& f, char c ){
  range_to_bytes(f, &c, &c+1);
}
template<class F>
void to_bytes( F&& f, int i ){
  range_to_bytes(f, (const char*)(&i), (const char*)(&i+1));
}
template<class F>
void to_bytes( F&& f, char const* str ){
  range_to_bytes(f, str, str+strlen(str));
}
template<class F, class...Ts>
void to_bytes( F&& f, Ts const&... ts ){
  using discard=int[];
  (void)discard{0,(void(
    to_bytes(f, ts)
  ),0)...}
}
template<class...Ts>
std::vector<char> to_vector_bytes( Ts const&... ts ){
  std::size_t count = 0;
  to_bytes([&](char){++count;}, ts...);
  std::vector<char> r;
  r.reserve(count);
  to_bytes([&](char c){r.push_back(c);}, ts...);
  return r;
}

Answer 3

让我分享我的解决方案。与之前提出的一次相比，它的优势在于它适用于所有类型：基本类型、静态数组、自定义对象、容器（向量、列表、字符串...）、C 字符串（文字和动态分配）。

如果您想限制这些类型（例如，不允许打包指针），您可以随时添加更多 SFINAE :) 或者只是一个 static_assert...

// byte_pack.h

#include <vector>
#include <type_traits>

// a small trait to check if it is possible to iterate over T
template<typename T, typename = void>
constexpr bool is_iterable = false;

template<typename T>
constexpr bool is_iterable<T, decltype(
        std::begin(std::declval<T&>()) != std::end(std::declval<T&>()), void())> = true;

typedef std::vector<std::uint8_t> byte_pack; // vector of bytes itself

template<typename T, std::enable_if_t<(!is_iterable<T>)>* = nullptr>
void pack(byte_pack& bytes, const T& value)  // for not iteratable values (int, double, custom objects, etc.)
{
    typedef const std::uint8_t byte_array[sizeof value];
    for(auto& byte : reinterpret_cast<byte_array&>(value)) {
        bytes.push_back(byte);
    }
}

template<typename T, std::enable_if_t<is_iterable<T>>* = nullptr>
void pack(byte_pack& bytes, const T& values) // for iteratable values (string, vector, etc.)
{
    for(const auto& value : values) {
        pack(bytes, value);
    }
}

template<>
inline void pack(byte_pack& bytes, const char* const & c_str) // for C-strings
{
    for(auto i = 0; c_str[i]; ++i) {
        bytes.push_back(c_str[i]);
    }
}

template<>
inline void pack(byte_pack& bytes, char* const & c_str) { // for C-strings
    pack(bytes, static_cast<const char*>(c_str));
}

template<typename T, size_t N>
void pack(byte_pack& bytes, const T (&values) [N])  // for static arrays
{
    for(auto i = 0u; i < N; ++i) {
        pack(bytes, values[i]);
    }
}

// finally a variadic overload
template<typename... Args>
byte_pack pack(const Args&... args)
{
    byte_pack bytes;
    int dummy[] = { 0, (pack(bytes, args), 0) ... };
    return bytes;
}

---

测试：

#include "byte_pack.h"

void cout_bytes(const std::vector<std::uint8_t>& bytes)
{
    for(unsigned byte : bytes) {
        std::cout << "0x" << std::setfill('0') << std::setw(2) << std::hex
                   << byte << " ";
    }
    std::cout << std::endl;
}

int main()
{
    // your example
    char c = 0x10; int x = 4; const char* s = "AAA";
    cout_bytes(pack(c, x, s));

    // static arrays and iterateble objects
    char                            matrix1[2][2] = { {0x01, 0x01},  {0xff, 0xff} };
    std::vector<std::vector<char>>  matrix2       = { {(char) 0x01, (char) 0x01},  {(char) 0xff, (char) 0xff} };
    cout_bytes(pack(matrix1, matrix2));

    // strings
    char*       str2 = new char[4] { "AAA" };
    std::string str1 = "AAA";
    cout_bytes(pack(str1, str2));

    // custom objects (remember about alignment!)
    struct { char a = 0x01;     short b = 0xff; }   object1;
    struct { short a = 0x01ff;  char b = 0x01; }    object2;
    cout_bytes(pack(object1, object2));

    return 0;
}

输出：

0x10 0x04 0x00 0x00 0x00 0x41 0x41 0x41
0x01 0x01 0xff 0xff 0x01 0x01 0xff 0xff
0x41 0x41 0x41 0x41 0x41 0x41
0x01 0x00 0xff 0x00 0xff 0x01 0x01 0x00