La sérialisation de l'objet de tableau d'octets en C++

Il est probable que votre code pour save et load sera raisonnablement générique et qui fonctionnent le mieux dans un autre de "gestionnaire" de la classe, laissant à chaque classe de données seulement avec la responsabilité de rendu lui-même en tant que re-chargeable:

//Interface class
class Serializable
{
public:
    virtual size_t serialize_size() const = 0;
    virtual void serialize(char* dataOut) const = 0;
    virtual void deserialize(const char* dataIn) = 0;
};

//Load /save manager
class EEPromManager
{
public:
    void save( const Serializable& s )
    {
        char * data;
        size_t data_len;
        reserve_memory( data, data_len, s );
        s.serialize( data );
        EEPROM::Save( data , data_len );
        delete [] data;
    }

    void load( Serializable& s )
    {
        char * data;
        size_t data_len;
        reserve_memory( data, data_len, s );
        EEPROM::Load( data, data_len );
        s.deserialize( data );
        delete [] data;
    }

private:
    char* reserve_memory( char*& data, size_t& data_len, const Serializable& s )
    {
        return new char[ s.serialize_size() ];
    }
};

Chaque classe vous avez l'intention de sérialiser /désérialiser doit hériter d'une interface qui donne mandat à l'interface virtuelle de ces fonctions. Notez que vous aurez besoin pour faire votre propre gestion de la mémoire ici. Je vous ai donné un exemple simple, mais vous voudrez probablement quelque chose d'un peu plus robuste.

Ensuite, chaque fonction doit séquentiellement sérialiser tous les attributs de la classe (chaînage des bases de classes et de l'appel de serialize sur l'ensemble des objets si nécessaire.)

class Person : public Serializable
{
public:
    virtual size_t serialize_size() const
    {
        return SerializablePOD<char*>::serialize_size(name) +
               SerializablePOD<int>::serialize_size(age) +
               SerializablePOD<float>::serialize_size(weight);
    }

    virtual void serialize(char* dataOut) const
    {
        dataOut = SerializablePOD<char*>::serialize(dataOut, name);
        dataOut = SerializablePOD<int>::serialize(dataOut, age);
        dataOut = SerializablePOD<float>::serialize(dataOut, weight);
    }
    virtual void deserialize(const char* dataIn)
    {
        dataIn = SerializablePOD<char*>::deserialize(dataIn, name);
        dataIn = SerializablePOD<int>::deserialize(dataIn, age);
        dataIn = SerializablePOD<float>::deserialize(dataIn, weight);
    }

private:
    char* name;
    int   age;
    float weight;
};

Vous bénéficiez d'un code générique pour sérialiser /désérialiser chaque type distinct de sorte que vous ne gardez pas avoir de code à écrire la longueur des chaînes, etc. I. e. un sérialiser /désérialiser pour chaque type de POD:

template <typename POD>
class SerializablePOD
{
public:
    static size_t serialize_size(POD str)
    {
        return sizeof(POD);
    }
    static char* serialize( char* target, POD value )
    {
        return memcpy( target, &value, serialize_size(value) );
    }
    static const char* deserialize( const char* source, POD& target )
    {
        memcpy( &target, source, serialize_size(target) );
        return source + serialize_size(target);
    }
};

template<>
size_t SerializablePOD<char*>::serialize_size(char* str)
{
    return sizeof(size_t) + strlen(str);
}

template<>
const char* SerializablePOD<char*>::deserialize( const char* source, char*& target )
{
    size_t length;
    memcpy( &length, source, sizeof(size_t) );
    memcpy( &target, source + sizeof(size_t), length );
    return source + sizeof(size_t) + length;
}

D'ailleurs, vous pourriez aussi avoir besoin d'envisager ce qui va se produire si vous modifiez le schéma d'un objet dans une mise à jour du logiciel. Vos objets sauvés pourrait être endommagé sur le rechargement, à moins que vous code ronde cette aide - par exemple - une classe identificateur de version.

Dernière pensée: Au niveau micro, ce que vous faites est à bien des égards similaire à la façon dont la GOUSSE de données est sérialisé pour la transmission sur le réseau, donc peut-être que vous pouvez prendre avantage des bibliothèques, le faire - même si vous n'avez pas accès à un système d'exploitation.

OriginalL'auteur Component 10