在C中将64位unsigned int来回转换为char缓冲区

Question

我的目标是通过网络发送以网络字节顺序的 64 位无符号整数开头的数据报。所以首先我使用宏将数字转换为大端：

#define htonll(x) ((1==htonl(1)) ? (x) : ((uint64_t)htonl((x) & 0xFFFFFFFF) << 32) | htonl((x) >> 32))
#define ntohll(x) ((1==ntohl(1)) ? (x) : ((uint64_t)ntohl((x) & 0xFFFFFFFF) << 32) | ntohl((x) >> 32))

然后我将它序列化到缓冲区中：

unsigned char * serialize_uint64(unsigned char *buffer, uint64_t value) {
  printf("**** seriializing PRIu64 value = %"PRIu64"\n", value);
  int i;
  for (i = 0; i < 8; i++)
    buffer[i] = (value >> (56 - 8 * i)) & 0xFF;
  for (i = 0; i < 8; i++)
    printf("bufer[%d] = %x\n", i, buffer[i]);

  return buffer + 8;
}

然后我用

反序列化它

uint64_t deserialize_uint64(unsigned char *buffer) {
  uint64_t res = 0;
  printf("*** deserializing buffer:\n");
  int i;
  for (i = 0; i < 8; i++)
    printf("bufer[%d] = %x\n", i, buffer[i]);
  for (i = 0; i < 8; i++)
    res |= buffer[i] << (56 - 8 * i);


  return res;
}

它似乎适用于小整数，但以下测试代码无法正常工作：

uint64_t a = (uint64_t) time(NULL);
printf("PRIu64: a =%"PRIu64"\n", a);

uint64_t z = htonll(a);
uint64_t zz = ntohll(z);
printf("z = %"PRIu64" ==> zz = %"PRIu64" \n", z, zz);

unsigned char buffer[1024];
serialize_uint64(buffer, z);
uint64_t b = deserialize_uint64(buffer);
uint64_t c = ntohll(g);

据我所知

a = 1494157850
htonll(a) = 1876329069679738880 ==> ntohll(htonll(a)) = 1494157850 
**** seriializing PRIu64 value = 1876329069679738880
bufer[0] = 1a
bufer[1] = a
bufer[2] = f
bufer[3] = 59
bufer[4] = 0
bufer[5] = 0
bufer[6] = 0
bufer[7] = 0
*********
*** deserializing buffer:
bufer[0] = 1a
bufer[1] = a
bufer[2] = f
bufer[3] = 59
bufer[4] = 0
bufer[5] = 0
bufer[6] = 0
bufer[7] = 0
===> res = 436866905
c = 6417359100811673600

缓冲区似乎没有捕获更大的数字...

Answer 1

你的序列化器本质上是

unsigned char *serialize_u64(unsigned char *buffer, uint64_t value)
{
    buffer[7] = value & 0xFF;
    value >>= 8;
    buffer[6] = value & 0xFF;
    value >>= 8;
    buffer[5] = value & 0xFF;
    value >>= 8;
    buffer[4] = value & 0xFF;
    value >>= 8;
    buffer[3] = value & 0xFF;
    value >>= 8;
    buffer[2] = value & 0xFF;
    value >>= 8;
    buffer[1] = value & 0xFF;
    value >>= 8;
    buffer[0] = value & 0xFF;
    return buffer + 8;
}

并将 value 从本机字节顺序序列化为网络字节顺序；不需要宏。

所以，看起来 OP 的 serialize_uint64() 应该工作得很好。只是根本不应该使用字节顺序宏。

OP 的 deserialize_uint64() 应在移位前将 buffer[i] 转换为 (uint64_t)，以确保移位结果为 64 位。就个人而言，我更喜欢将反序列化器编写为

unsigned char *serialize_u64(unsigned char *buffer, uint64_t *valueptr)
{
    uint64_t value = buffer[0];
    value <<= 8;
    value |= buffer[1];
    value <<= 8;
    value |= buffer[2];
    value <<= 8;
    value |= buffer[3];
    value <<= 8;
    value |= buffer[4];
    value <<= 8;
    value |= buffer[5];
    value <<= 8;
    value |= buffer[6];
    value <<= 8;
    value |= buffer[7];
    *valueptr = value;
    return buffer + 8;
}

如果 OP 使用 res |= ((uint64_t)buffer[i]) << (56 - 8 * i); 代替，它执行与 OP 相同的操作。

同样，序列化器和反序列化器都已经将数据转换为 to/from 网络字节顺序 from/to 本机字节顺序；根本不应使用字节顺序宏。

在C中将64位unsigned int来回转换为char缓冲区

Convert 64 bit unsigned int to char buffer back and forth in C

c

string

64-bit