Question

1）我有一个很大的缓冲区 2）我有很多几乎所有类型的变量，

我使用此缓冲区以不同的字节顺序发送到多个目的地。

当我发送到网络字节顺序时，我通常使用htons，或htonl和特定数据类型的自定义函数，

所以我的问题，

每次构建缓冲区时，我都会更改每个变量的字节顺序，然后使用memcpy。

但是，有没有人知道更好的方法，就像我希望有一个特定的预期字节顺序的高效memcpy

一个例子，

UINT32 dwordData = 0x01234567;
UINT32 dwordTmp = htonl(dwordData);
memcpy(&buffer[loc], &dwordTmp, sizeof(UNIT32));
loc += sizeof(UNIT32);

这只是我随机写的btw

的一个例子

我希望看起来像

的功能

memcpyToNetwork(&buffer[loc], &dwordTmp, sizeof(UNIT32));

如果你知道我的意思，命名只是一个描述性的，并且根据数据类型，它执行特定数据类型的字节顺序，所以我不必手动更改订单并有一个临时变量要复制到，保存复制两次。

Answer 1

没有标准的解决方案，但写自己很容易。

在我的头顶上，轮廓可能如下所示：

// Macro to be able to switch easily between encodings. Just for convenience
#define WriteBuffer WriteBufferBE 

// Generic template as interface specification. Not implemented itself
// Takes buffer (of sufficient size) and value, returns number of bytes written
template <typename T>
size_t WriteBufferBE(char* buffer, const T& value);

template <typename T>
size_t WriteBufferLE(char* buffer, const T& value);

// Specializations for specific types
template <>
size_t WriteBufferBE(char* buffer, const UINT32& value)
{
    buffer[0] = (value >> 24) & 0xFF;
    buffer[1] = (value >> 16) & 0xFF;
    buffer[2] = (value >> 8) & 0xFF;
    buffer[3] = (value) & 0xFF;
    return 4;
}

template <>
size_t WriteBufferBE(char* buffer, const UINT16& value)
{
    buffer[0] = (value >> 8) & 0xFF;
    buffer[1] = (value) & 0xFF;
    return 2;
}

template <>
size_t WriteBufferLE(char* buffer, const UINT32& value)
{
    buffer[0] = (value) & 0xFF;
    buffer[1] = (value >> 8) & 0xFF;
    buffer[2] = (value >> 16) & 0xFF;
    buffer[3] = (value >> 24) & 0xFF;
    return 4;
}

template <>
size_t WriteBufferLE(char* buffer, const UINT16& value)
{
    buffer[0] = (value) & 0xFF;
    buffer[1] = (value >> 8) & 0xFF;
    return 2;
}

// Other types left as an exercise. Can use the existing functions!

// Usage:
loc += writeBuffer(&buffer[loc], dwordData);

特定字节序c / c ++的memcpy

1 个答案: