C++ 将变量参数列表序列化为C+；中字节数组的最佳方法+；？

我有一个C实现，其中我将变量列表的参数序列化为字节数组。 因此，我可以将一定数量的变量保存到一个文件中

C中的代码如下所示：

static uint8_t byte_array[1024];

/* In this example, we assume that fmt contains only 'c', 'i', or 'f'
   We also assume that an argument is available for each char in fmt.
*/

uint8_t * serialize_args(const char *fmt, ...) {
  char *ptr = fmt;
  uint32_t idx = 0;
  va_list args;
  va_start(args, fmt);

  while(*ptr != NULL) {
    char p = *ptr++;
    char c;
    int i;
    float f;

    switch(p) {
      case 'c':  /* serialize char */
        c = va_arg(args, int32_t);
        byte_array[idx++] = (uint8_t) c;
        break;
      case 'i':  /* serialize int */
        i = va_arg(args, int32_t);
        memcpy(&byte_array[idx], &i, sizeof i);
        idx += sizeof i;
        break;
      case 'f':  /* serialize float */
        f = (float)va_arg(args, double);
        memcpy(&byte_array[idx], &f, sizeof f);
        idx += sizeof f;
        break;
    }
  }    
  va_end(args, fmt);

  byte_array[idx++] = 0;
  return byte_array;
}

vector<uint8_t> serialize_args(const char *fmt, ...) {
  char *ptr = fmt;

  vector<uint8_t> byte_array;

  va_list args;
  va_start(args, fmt);

  while(*ptr != NULL) {
    char p = *ptr++;
    char c;
    int i;
    float f;

    switch(p) {
      case 'c':  // serialize char
        c = (char)va_arg(args, int32_t);
        byte_array.push_back(c);  // do I need a cast ?
        break;
      case 'i':  // serialize int
        i = va_arg(args, int32_t);
        // here how do I memcpy to a vector ?
        break;
      case 'f':  // serialize float
        f = (float)va_arg(args, double);
        // here how do I memcpy to a vector ?
        break;
    }
  }    

  va_end(args, fmt);

  return byte_array;
}

现在，我想用C++来翻译这个。哪种容器最合适？ 向量？我会这样看：

static uint8_t byte_array[1024];

/* In this example, we assume that fmt contains only 'c', 'i', or 'f'
   We also assume that an argument is available for each char in fmt.
*/

uint8_t * serialize_args(const char *fmt, ...) {
  char *ptr = fmt;
  uint32_t idx = 0;
  va_list args;
  va_start(args, fmt);

  while(*ptr != NULL) {
    char p = *ptr++;
    char c;
    int i;
    float f;

    switch(p) {
      case 'c':  /* serialize char */
        c = va_arg(args, int32_t);
        byte_array[idx++] = (uint8_t) c;
        break;
      case 'i':  /* serialize int */
        i = va_arg(args, int32_t);
        memcpy(&byte_array[idx], &i, sizeof i);
        idx += sizeof i;
        break;
      case 'f':  /* serialize float */
        f = (float)va_arg(args, double);
        memcpy(&byte_array[idx], &f, sizeof f);
        idx += sizeof f;
        break;
    }
  }    
  va_end(args, fmt);

  byte_array[idx++] = 0;
  return byte_array;
}

vector<uint8_t> serialize_args(const char *fmt, ...) {
  char *ptr = fmt;

  vector<uint8_t> byte_array;

  va_list args;
  va_start(args, fmt);

  while(*ptr != NULL) {
    char p = *ptr++;
    char c;
    int i;
    float f;

    switch(p) {
      case 'c':  // serialize char
        c = (char)va_arg(args, int32_t);
        byte_array.push_back(c);  // do I need a cast ?
        break;
      case 'i':  // serialize int
        i = va_arg(args, int32_t);
        // here how do I memcpy to a vector ?
        break;
      case 'f':  // serialize float
        f = (float)va_arg(args, double);
        // here how do I memcpy to a vector ?
        break;
    }
  }    

  va_end(args, fmt);

  return byte_array;
}

向量序列化参数（常量字符*fmt，…）{ char*ptr=fmt； 向量字节数组； va_列表参数； va_启动（参数、fmt）； while（*ptr！=NULL）{ charp=*ptr++； 字符c； int i； 浮动f； 开关（p）{ 案例“c”：//序列化字符 c=（char）va_arg（args，int32_t）； 字节数组。推回（c）；//我需要强制转换吗？ 打破 案例'i'：//序列化int i=va_arg（args，int32_t）； //这里我如何记忆向量？ 打破 案例“f”：//序列化浮点 f=（浮点）va_arg（args，双精度）； //这里我如何记忆向量？ 打破 } } va_端（args、fmt）； 返回字节数组； }

---

有什么建议吗？

使用指向字符类型的指针来别名任何类型都是合法的，因此您可以执行以下操作（例如

int

）：

或者，也许更惯用的说法是：

std::copy(&i, &i + sizeof(int), std::back_inserter(byte_array));

您也可以使用

memcpy

，但需要事先使用vector的

resize

方法为

sizeof（int）

字节腾出空间

在C++11中，您将完全摆脱varargs，并使用可变模板函数