将char缓冲区转换为struct

Question

I have a char buffer buf containing buf[0] = 10 , buf[1] = 3 , buf[2] = 3 , buf[3] = 0 , buf[4] = 58 ,

and a structure:

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

I wanted to convert the buf into a Header . Now I am using the function

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 
}

I am searching for a solution such as

 Header *head = new Header;

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

In this, first value in the Header , head->type is proper and rest is garbage. Is it possible to convert unsigned char* buf to Header ?

Answer 1

The only full portable and secure way is:

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];
}

and

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;
}

Example

see Converting bytes array to integer for explanations

EDIT

A quick summary of previous link: other possible solutions ( memcpy or union for example) are no portable according endianess of different system (doing what you do is probably for a sort of communication between at least two heterogeneous systems) => some of systems byte[0] is LSB of int and byte[1] is MSB and on other is the inverse.

Also, due to alignement, struct Header can be bigger than 5 bytes (probably 6 bytes in your case, if alignement is 2 bytes!) (see here for example)

Finally, according alignment restrictions and aliasing rules on some platform, compiler can generate incorrect code.

Answer 2

What you want would need your version and length to have the same length as 2 elements of your buf array; that is you'd need to use the type uint16_t , defined in <cstdint> , rather than int which is likely longer. And also you'd need to make buf an array of uint8_t , as char is allowed to take more than 1 byte!

You probably also need to move type to the end; as otherwise the compiler will almost certainly insert a padding byte after it to be able to align version to a 2-byte boundary (once you have made it uint16_t and thus 2 bytes); and then your buf[1] would end up there rather than were you want it. This is probably what you observe right now, by the way: by having a char followed by an int , which is probably 4 bytes, you have 3 bytes of padding, and the elements 1 to 3 of your array are being inserted there (=lost forever).

Another solution would be to modify your buf array to be longer and have empty padding bytes as well, so that the data will be actually aligned with the struct fields.

Worth mentioning again is that, as pointed out in the comments, sizeof(head) returns the size of pointers on your system, not of the Header structure. You can directly write sizeof(Header) ; but at this level of micromanagement, you wont be losing any more flexibility if you just write " 5 ", really.

Also, endianness can screw with you. Processors have no obbligation to store the bytes of a number in the order you expect rather than the opposite one; both make internal sense after all. This means that blindly copying bytes buf[0], buf[1] into a number can result in (buf[0]<<8)+buf[1] , but also in (buf[1]<<8)+buf[0] , or even in (buf[1]<<24)+(buf[0]<<16) if the data type is 4 bytes (as int usually is). And even if it works on your computer now, there is at least one out there where the same code will result in garbage. Unless, that is, those bytes actually come from reinterpreting a number in the first place. In which case the code is wrong (not portable) now , however.

...is it worth it?

All things considered, my advice is strongly to keep the way you handle them now. Maybe simplify it.

It really makes no sense to convert a byte to an int then to byte again, or to take the address of a byte to dereference it again, nor there is need of helper variables with no descriptive name and no purpose other than being returned, or of a variable whose value you know in advance at all time.

Just do

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

the better way is to create some sort of serialization/deserialization routines.

also, I'd use not just int or char types, but would use more specific int32_t etc. it's just platform-independent way (well, actually you can also pack your data structures with 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);