CODEWITHSUNDEEP
c++serialization
John Humphreys
John Humphreys

Reputation: 39294

C++ way to serialize a message?

In my current project I have a few different interfaces that require me to serialize messages into byte buffers. I feel like I'm probably not doing it in a way that would make a true C++ programmer happy (and I'd like to).

I would typically do something like this:

struct MyStruct {
    uint32_t x;
    uint64_t y;
    uint8_t  z[80];
};

uint8_t* serialize(const MyStruct& s) {
    uint8_t* buffer = new uint8_t[sizeof(s)];
    uint8_t* temp = buffer;
    memcpy(temp, &s.x, sizeof(s.x));
    temp += sizeof(s.x);

    //would also have put in network byte order...
    ... etc ...

    return buffer;
}

Excuse any typos, that was just an example off the top of my head. Obviously it can get more complex if the structure I'm serializing has internal pointers.

So, I have two questions that are closely related:

  1. Is there any problem in the specific scenario above with serializing by casting the struct directly to a char buffer assuming I know that the destination systems are in the same endianness?

  2. Main question: Is there a better... erm... C++? way to do this aside from the addition of smart pointers? I feel like this is such a common problem that the STL probably handles it - and if it doesn't, I'm sure there's a better way to do it anyway using C++ mechanisms.

EDIT Bonus points if you can do a clean example of serializing this structure in a better way using standard C++/STL without added libraries.

Upvotes: 3

Views: 3194

Answers (3)

citykid
citykid

Reputation: 11070

just voted AzPs reply as the answer, checking Boost first is the way to go.

in addition about your code sample:

1 - changing the signature of your serialization function to a method taking a file:

void MyStruct::serialize(FILE* file) // or stream
{
    int size = sizeof(this);
    fwrite(&size, sizeof(int), 1, file); // write size
    fwrite(this, 1, size, file);         // write raw bytes of struct
}

reduces the necessity to copy the struct.

2 - yes, your code makes the serialized bytes dependent on your platform, compiler and compiler settings. this is not good or bad, if the same binary writes and reads the serialized bytes, this might be beneificial because of simplicity and performance. But it is not only endianness, also packing and struct layout affects compatibility. For instance a 32bit or a 64bit version of your app will change the layout of our struct quite for sure. Finally serializing the raw footprint also serializes padding bytes - the bytes the compiler might put between struct fields, an overhead undesirable for high traffic network streams (see google protocol buffers as they hunt every bit they can save).

EDIT:

i see you added "embedded". yes, then such simple serialize / deserialize (mirror implementation of the above serialize) methods might be a good and simple choice.

Upvotes: 1

Sean
Sean

Reputation: 62492

You might want to take a look at Google Protocol Buffers (also known as protobuf). You define your data in a language neutral IDL and then run it through a generator to generate your C++ classes. It'll take care of byte ordering issues and can provide a very compact binary form.

By using this you'll not only be able to save your C++ data but it'll be useable in other languages (C#, Java, Python etc) as there are protobuf implementation available for them.

Upvotes: 6

AzP
AzP

Reputation: 1101

You should probable use either Boost::serialization or streams directly. More information in either of the links to the right.

Is it possible to serialize and deserialize a class in C++?

Upvotes: 6

Related Questions