将char缓冲区转换为struct

Question

我有一个char缓冲区buf包含buf[0] = 10 ， buf[1] = 3 ， buf[2] = 3 ， buf[3] = 0 ， buf[4] = 58 ，

和一个结构：

typedef struct
{ 
    char type;
    int version;
    int length;
}Header;

我想将buf转换为Header 。 现在我正在使用该功能

int getByte( unsigned char* buf)
{
    int number = buf[0]; 
    return number;
}

int getInt(unsigned char* buf)
{
    int number =  (buf[0]<<8)+buf[1];
    return number;
}

main()
{
    Header *head = new Header;
    int location = 0;

    head->type = getByte(&buf[location]);
    location++;     // location = 1

    head->version = getInt(&buf[location]);
    location += 2;  // location = 3

    head->ength = getInt(&buf[location]);
    location += 2;  // location = 5 
}

我正在寻找解决方案，例如

 Header *head = new Header;

 memcpy(head, buf, sizeof(head));

在此， Header ， head->type中的第一个值是正确的，而其余的是垃圾。 是否可以将unsigned char* buf转换为Header ？

Answer 1

唯一完整的便携式安全方式是：

void convertToHeader(unsigned char const * const buffer, Header *header)
{
    header->type = buffer[0];
    header->version = (buffer[1] <<  8) | buffer[2];
    header->length = (buffer[3] <<  8) | buffer[4];
}

和

void convertFromHeader(Header const * const header, unsigned char * buffer)
{
    buffer[0] = header->type;
    buffer[1] = (static_cast<unsigned int>(header->version) >>  8) & 0xFF;
    buffer[2] = header->version & 0xFF;
    buffer[3] = (static_cast<unsigned int>(header->length) >>  8) & 0xFF;
    buffer[4] = header->length & 0xFF;
}

例

请参阅将字节数组转换为整数以获取解释

编辑

以前的链接的简要概述：其他可能的解决方案（例如memcpy或union ）根据不同系统的固有性是不可移植的（您所做的可能是至少两个异构系统之间的一种通信）=>一些系统字节[0]是int的LSB，而字节[1]是MSB，反之亦然。

另外，由于对齐， struct Header可以大于5个字节（如果对齐为2个字节，则可能大于6个字节！）（例如，请参见此处 ）

最后，根据某些平台上的对齐限制和别名规则，编译器可能会生成错误的代码。

Answer 2

您想要的内容将需要您的version和length与buf数组的2个元素具有相同的长度； 那就是您需要使用在<cstdint>定义的uint16_t类型，而不是可能更长的int类型。 而且您还需要使buf成为uint8_t数组，因为char可以占用1个以上字节！

您可能还需要将type移到末尾。 否则，编译器几乎肯定会在其后插入一个填充字节，以便将version与2字节边界对齐（一旦您将其设置为uint16_t ，即2字节）； 然后您的buf[1]最终会在那里而不是您想要的。 顺便说一下，这可能就是您现在所观察到的：通过在char后面加上一个int （可能是4个字节），您将有3个字节的填充，并且您的数组元素1到3将插入其中（=永远失去了）。

另一个解决方案是将buf数组修改为更长，并且具有空的填充字节，以使数据实际与struct字段对齐。

再次值得一提的是，正如注释中指出的那样， sizeof(head)返回系统上指针的大小，而不是Header结构的大小。 您可以直接写sizeof(Header) ; 但是在这种微观管理水平上，如果您只写“ 5 ”，您将不会再失去更多的灵活性。

此外，字节序可以与您联系。 处理器没有义务按照您期望的顺序而不是相反的顺序存储数字的字节。 毕竟，两者都有内在的道理。 这意味着将字节buf[0], buf[1]盲目复制到数字中可能会导致(buf[0]<<8)+buf[1] ，但也会导致(buf[1]<<8)+buf[0] ，或者如果数据类型为4个字节（通常为int (buf[1]<<24)+(buf[0]<<16)则甚至以(buf[1]<<24)+(buf[0]<<16)表示。 即使它现在可以在您的计算机上运行，​​也至少有一个地方使用相同的代码会导致垃圾回收。 除非是，否则这些字节实际上首先来自重新解释数字。 但是，在这种情况下， 现在的代码是错误的（不可移植）。

...这值得么？

考虑到所有问题，我的建议是强烈保留您现在处理它们的方式。 也许简化一下。

将字节转换为int然后再次转换为字节，或者使用字节的地址再次对其进行取消引用确实没有任何意义，也不需要辅助变量，而该辅助变量没有描述性的名称，除了返回以外没有其他用途，或者您始终可以事先知道其值的变量。

做就是了

int getTwoBytes(unsigned char* buf)
{
    return (buf[0]<<8)+buf[1];
}

main()
{
    Header *head = new Header;

    head->type = buf[0];

    head->version = getTwoBytes(buf + 1);

    head->length = getTwoBytes(buf + 3);
}

Answer 3

更好的方法是创建某种序列化/反序列化例程。

同样，我不仅会使用int或char类型，还会使用更具体的int32_t等。这只是与平台无关的方式（嗯，实际上，您也可以使用pragma pack打包数据结构）。

    struct Header
    {
        char16_t type;
        int32_t version;
        int32_t length;
    };
    struct Tools
    {
        std::shared_ptr<Header> deserializeHeader(const std::vector<unsigned char> &loadedBuffer)
        {
            std::shared_ptr<Header> header(new Header);
            memcpy(&(*header), &loadedBuffer[0], sizeof(Header));
            return header;
        }
        std::vector<unsigned char> serializeHeader(const Header &header)
        {
            std::vector<unsigned char> buffer;
            buffer.resize(sizeof(Header));
            memcpy(&buffer[0], &header, sizeof(Header));
            return buffer;
        }
    }
    tools;
    Header header = {'B', 5834, 4665};
    auto v1 = tools.serializeHeader(header);
    auto v2 = tools.deserializeHeader(v1);