Sérialisation d'objets en C++ : bibliothèques, méthodes et exemples de code

Sérialisation d'objets en C++ : guide complet

La sérialisation est le processus de conversion de structures de données complexes (objets de classes, conteneurs) en un format séquentiel (flux d'octets, chaîne JSON, XML) adapté à la sauvegarde dans un fichier ou à la transmission sur un réseau. Le processus inverse — la désérialisation — reconstruit l'objet à partir de ce format. En C++, où il n'existe pas de réflexion intégrée, la sérialisation nécessite une description manuelle ou l'utilisation de bibliothèques spécialisées. Dans cet article, nous examinerons les principales approches et les meilleurs outils pour la sérialisation en C++.

Pourquoi la sérialisation est-elle nécessaire ?

• Sauvegarde d'état — enregistrement de parties sauvegardées de jeux, de paramètres d'application.
• Communication réseau — transmission d'objets entre un client et un serveur.
• Mise en cache — sauvegarde des résultats de calculs dans un fichier.
• Échange de données — intégration avec d'autres langages (JSON, Protobuf).

Bibliothèques populaires pour la sérialisation en C++

1. Boost.Serialization

Bibliothèque classique de la suite Boost. Prend en charge la sérialisation binaire, textuelle et XML. Nécessite l'ajout explicite de méthodes serialize ou save/load.

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

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

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

2. Cereal

Bibliothèque moderne et légère (fichiers d'en-tête uniquement). Prend en charge JSON, XML, format binaire. Ne nécessite pas d'héritage de classes de base. Idéale pour les projets qui n'ont pas besoin de tout Boost.

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

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

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

3. nlohmann/json (JSON pour le C++ moderne)

N'est pas une bibliothèque de sérialisation au sens classique, mais permet de convertir facilement des objets en JSON et vice versa. Nécessite l'écriture manuelle de fonctions de conversion.

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

// UtilisationPoint p1{10, 20};json j = p1;                  // sérialisationPoint p2 = j.get<Point>();    // désérialisation

4. Protocol Buffers (protobuf)

Développé par Google. Nécessite la description des structures dans des fichiers .proto, après quoi le code C++ est généré. Promet un format binaire compact et une vitesse élevée.

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