Objekt-Serialisierung in C++: Bibliotheken, Methoden und Codebeispiele

Objekt-Serialisierung in C++: Vollständiger Leitfaden

Serialisierung ist der Prozess der Umwandlung komplexer Datenstrukturen (Klassenobjekte, Container) in ein sequentielles Format (Bytestrom, JSON-String, XML), das zum Speichern in einer Datei oder zur Übertragung über ein Netzwerk geeignet ist. Der umgekehrte Prozess – die Deserialisierung – stellt das Objekt aus diesem Format wieder her. In C++, das keine eingebaute Reflexion hat, erfordert die Serialisierung eine manuelle Beschreibung oder die Verwendung spezialisierter Bibliotheken. In diesem Artikel werden wir die grundlegenden Ansätze und die besten Werkzeuge für die Serialisierung in C++ untersuchen.

Wozu dient die Serialisierung?

• Zustandsspeicherung – Speichern von Spielständen, Anwendungseinstellungen.
• Netzwerkkommunikation – Übertragung von Objekten zwischen Client und Server.
• Caching – Speichern von Berechnungsergebnissen in einer Datei.
• Datenaustausch – Integration mit anderen Sprachen (JSON, Protobuf).

Beliebte Bibliotheken für die Serialisierung in C++

1. Boost.Serialization

Klassische Bibliothek aus dem Boost-Paket. Unterstützt binäre, textuelle und XML-Serialisierung. Erfordert das explizite Hinzufügen von serialize- oder save/load-Methoden.

#include <boost/archive/text_oarchive.hpp>#include <boost/archive/text_iarchive.hpp>#include <fstream>

class Person {public:    std::string name;    int age;        template<class Archive>    void serialize(Archive& ar, const unsigned int version) {        ar & name;        ar & age;    }};

// Speichernvoid save(const Person& p) {    std::ofstream ofs("person.txt");    boost::archive::text_oarchive oa(ofs);    oa << p;}

// LadenPerson load() {    Person p;    std::ifstream ifs("person.txt");    boost::archive::text_iarchive ia(ifs);    ia >> p;    return p;}

2. Cereal

Moderne, leichte Bibliothek (nur Header-Dateien). Unterstützt JSON, XML, binäres Format. Erfordert keine Vererbung von Basisklassen. Ideal für Projekte, die nicht das gesamte Boost benötigen.

#include <cereal/archives/json.hpp>#include <cereal/types/string.hpp>#include <cereal/types/vector.hpp>#include <fstream>

struct Student {    std::string name;    std::vector<int> grades;        template<class Archive>    void serialize(Archive& ar) {        ar(CEREAL_NVP(name), CEREAL_NVP(grades));    }};

// Speichern als JSONvoid saveStudent(const Student& s) {    std::ofstream ofs("student.json");    cereal::JSONOutputArchive archive(ofs);    archive(CEREAL_NVP(s));}

// Laden aus JSONStudent loadStudent() {    Student s;    std::ifstream ifs("student.json");    cereal::JSONInputArchive archive(ifs);    archive(s);    return s;}

3. nlohmann/json (JSON für modernes C++)

Ist keine Serialisierungsbibliothek im klassischen Sinne, ermöglicht aber die einfache Konvertierung von Objekten in JSON und zurück. Erfordert das manuelle Schreiben von Konvertierungsfunktionen.

#include <nlohmann/json.hpp>using json = nlohmann::json;

struct Point {    int x, y;};

void to_json(json& j, const Point& p) {    j = json{{"x", p.x}, {"y", p.y}};}

void from_json(const json& j, Point& p) {    j.at("x").get_to(p.x);    j.at("y").get_to(p.y);}

// VerwendungPoint p1{10, 20};json j = p1;                  // SerialisierungPoint p2 = j.get<Point>();    // Deserialisierung

4. Protocol Buffers (protobuf)

Entwickelt von Google. Erfordert die Beschreibung von Strukturen in .proto-Dateien, woraus dann C++-Code generiert wird. Verspricht ein kompaktes binäres Format und hohe Geschwindigkeit.

// Datei person.protosyntax = "proto3";message P