In quali tipi si può suddividere la serializzazione…

La serializzazione può essere suddivisa nei seguenti tipi fondamentali, in base al modo in cui i dati vengono rappresentati:

Testuale: I dati sono rappresentati in un formato leggibile, di solito sotto forma di stringhe.
- Vantaggi: Facilità di debug, indipendenza dall'architettura.
- Svantaggi: Maggiore volume di dati, necessità di parsing.
- Esempi: JSON, XML, YAML.
Binaria: I dati sono rappresentati in un formato grezzo, binario.
- Vantaggi: Compattezza, alta velocità di serializzazione/deserializzazione.
- Svantaggi: Lettura dei dati difficile senza schema, possibili problemi di compatibilità tra diverse architetture (ad esempio, endianness).
- Esempi: Protocol Buffers, Apache Thrift, Cap'n Proto, MessagePack.

Inoltre, la serializzazione può essere classificata in base al metodo di applicazione:

Manuale: Lo sviluppatore scrive esplicitamente il codice per convertire i dati dell'oggetto in byte e viceversa.

Esempio:

// Esempio di serializzazione manuale di int
int data = 12345;
std::vector<char> buffer;
buffer.resize(sizeof(int));
std::memcpy(buffer.data(), &data, sizeof(int));

Automatica (riflessione/generazione di codice): Si utilizzano librerie o strumenti che eseguono automaticamente la serializzazione/deserializzazione sulla base delle informazioni sulla struttura dei dati.

Esempio: Uso di librerie come Boost.Serialization, cereal, RapidJSON (con adattatori personalizzati), o strumenti di generazione di codice per Protocol Buffers.

// Esempio di utilizzo di boost::serialization
#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <fstream>
#include <iostream>

struct MyData {
    int x;
    double y;

    template<class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        ar & x;
        ar & y;
    }
};

void save(const MyData& data, const std::string& filename) {
    std::ofstream ofs(filename);
    boost::archive::binary_oarchive oa(ofs);
    oa << data;
}

void load(MyData& data, const std::string& filename) {
    std::ifstream ifs(filename);
    boost::archive::binary_iarchive ia(ifs);
    ia >> data;
}

È inoltre importante considerare:

Schema vs Senza schema: È richiesta una definizione esplicita della struttura dei dati (schema) o il formato dei dati è auto-descrittivo?
Stream vs Bufferizzato: La serializzazione può avvenire durante la ricezione dei dati o è necessario caricare tutto il volume dei dati in memoria prima di serializzare/deserializzare?

In quali tipi si può suddividere la serializzazione?