Serialización de objetos en C++: bibliotecas, métodos y ejemplos de código

Serialización de objetos en C++: guía completa

La serialización es el proceso de convertir estructuras de datos complejas (objetos de clases, contenedores) en un formato secuencial (flujo de bytes, cadena JSON, XML), adecuado para guardar en un archivo o transmitir por red. El proceso inverso — la deserialización — restaura el objeto desde ese formato. En C++, donde no hay reflexión incorporada, la serialización requiere descripción manual o el uso de bibliotecas especializadas. En este artículo, analizaremos los enfoques principales y las mejores herramientas para la serialización en C++.

¿Para qué sirve la serialización?

• Guardar estado — guardar partidas de juegos, configuraciones de aplicaciones.
• Comunicación en red — transferir objetos entre cliente y servidor.
• Almacenamiento en caché — guardar resultados de cálculos en un archivo.
• Intercambio de datos — integración con otros lenguajes (JSON, Protobuf).

Bibliotecas populares para serialización en C++

1. Boost.Serialization

Biblioteca clásica del conjunto Boost. Soporta serialización binaria, textual y XML. Requiere agregar explícitamente los métodos serialize o 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;    }};

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

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

2. Cereal

Biblioteca moderna y ligera (solo archivos de cabecera). Soporta JSON, XML y formato binario. No requiere herencia de clases base. Es ideal para proyectos que no necesitan todo 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));    }};

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

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

3. nlohmann/json (JSON para C++ moderno)

No es una biblioteca de serialización en el sentido clásico, pero permite convertir fácilmente objetos a JSON y viceversa. Requiere escribir manualmente las funciones de conversión.

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

// UsoPoint p1{10, 20};json j = p1;                  // serializaciónPoint p2 = j.get<Point>();    // deserialización

4. Protocol Buffers (protobuf)

Desarrollado por Google. Requiere describir las estructuras en archivos .proto, tras lo cual se genera código en C++. Ofrece un formato binario compacto y alta velocidad.

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