How do you guys go about saving/loading (serialization/deserialization) objects in C++?

That's a tricky question because it depends on the level of loading you want to achieve. There is a difference in between loading “any” object from a serialized data source or just loading “known” objects at runtime. If you want to load nearly any object that might be possible in C++ then you need to overcome with some kind of RTTI/ Reflection system like what C# has. First you need to be able to determine the object type (via an ID) and load it's RTTI to be able to iterate and call the propper constructor method, while on a known object, the ID leads to some callback/ delegate that already contains code to properly assemble the object from it's binary source.

However, then there might be some methods involved that iterate over fields and properties to detect their type and reassemble step by step to the object instance that was saved to binary once.

I have done all of these recently while "knowing" was involved more in the sense of save files for games, a full fledged serializer/ deserializer has been used primary for tooling and editor code.

One implementation I currently use is half-half of both, some reflection like code is walking through a type on a precompilation step and locates those members that have a certain “attribute” attached to them (a comment that is formed like an Attribute in C# .e.g. //[Serializeable]) and collects those information for later use by a code generator. The code generator creates a function that is supposed to serialize the object instance into binary data and reassemble it from such data. The generator also adds property IDs to be able to have some kind of backwards compatibility to classes of a different version. They are simply defined in code (as an attribute) by the user and contain some header bytes that allow the assembly function to jump over the block of data if needed.

In code, I register certain types to their serializer and assembly functions on initialization. To get a clear type identification, I use a compiler macro that generates a type-ID for nearly every type possible in C++. The macro utilizes the __PRETTY_FUNCTION__ (and similar macros depending on the compiler) and some pointer shifting to get a more or less unifed name out of every type you can pass into a template function. The platform bound type-ID is then a 32 bit hash value of the string. But I also have some fixed IDs in code for types I need to be platform idependent (primitves for example) so it is a bit of both.

It works quite well at the moment and is fast in development as also production code

You can use Boost or Qt. I use Qt. Both contain helpers for serialization/deserialization.

Read this article: https://www.qt.io/blog/2018/05/31/serialization-in-and-with-qt​

Watch these tutorials:

• C++ Qt - Serialization basics
• C++ Qt - Serialization With Operators overload
• C++ Qt - Serialization Into File

I've seen systems that used a custom binary serialization format with read/write methods on the objects directly, reading/writing the entire game state directly to/from disk without any pre-processing or structure, data structures that could be pointed at your specific object that the serialization code would then read, code generators that used an interface definition language to generate the serialization functions, code generators that parsed the code directly, entirely separate systems that read subsets of the objects and compressed them for network transport, and hybrids of one or more of these things. And then there's all the libraries out there that do one or more of these things for you, like flatbuffers and protocolbuf and so on.

It's hard to give advice without knowing what your specific situation is, because each of these have their own use cases and problems.

• What are you trying to serialize?
• Where is the data going/coming from?
• How important is performance?
• What concessions are you willing to make about how the objects can be laid out in memory and what types they can contain?
• How much coupling are you willing to have between the objects and the serialization code?