Comment mettre en œuvre la sérialisation en C++

Chaque fois que je me retrouve à avoir besoin de sérialiser des objets dans un programme C++, je revenir à ce genre de modèle:

class Serializable {
  public:
    static Serializable *deserialize(istream &is) {
        int id;
        is >> id;
        switch(id) {
          case EXAMPLE_ID:
            return new ExampleClass(is);
          //...
        }
    }

    void serialize(ostream &os) {
        os << getClassID();
        serializeMe(os);
    }

  protected:
    int getClassID()=0;
    void serializeMe(ostream &os)=0;
};

Ci-dessus fonctionne très bien dans la pratique. Cependant, j'ai entendu dire que ce genre de commutation sur les Id de classe est mal et un antipattern; ce qui est la norme, OO-façon de gérer la sérialisation en C++?

  • que les récents changements ? Je n'ai certainement pas entendu parler de tout.
  • Je veux dire cette réponse: stackoverflow.com/a/10332336/1065190
  • Ah! Je pense que la section des commentaires sur la réponse elle-même sont probablement le meilleur endroit pour en discuter. En fait, j'ai déjà commencé. Il semble assez ésotérique pour moi, surtout l'idée de la fusion de la sérialisation automatique des getters et les setters (c'est généralement mauvais pour mélanger différents concepts). Me rappelle un certain QT projet... à la fin, vous avez quasi-C++ et vous perdez la portabilité, car vous êtes dépendante de la disponibilité de l'outil qui est censé la métamorphoser en bonne, compilable en C++. Je ne suis pas en retenant mon souffle.
  • Il est bon de prendre l'a pris avec la source et simplement recompiler sur la plate-forme cible. Qt a en effet un outil appelé metaobject compilateur qui génère de la métainformation pour votre projet C++.
  • double possible de Comment sérialiser en c++?
InformationsquelleAutor Paul | 2009-11-27
  1. 27

    En utilisant quelque chose comme Stimuler La Sérialisation, tandis que pas une norme, est une (pour la plupart) très bien écrit, la bibliothèque qui fait le gros du travail pour vous.

    La dernière fois que j'ai eu à analyser manuellement un prédéfinies de la structure de l'enregistrement avec une nette arbre d'héritage, j'ai fini à l'aide de la modèle de fabrique avec enregistrable classes (c'est à dire à l'Aide d'une carte de clé à un (modèle) créateur de la fonction plutôt que de beaucoup de fonctions de l'interrupteur) pour essayer d'éviter le problème que vous aviez.

    MODIFIER

    Une base de C++ mise en œuvre d'une fabrique d'objet mentionné dans le paragraphe ci-dessus.

    /**
* A class for creating objects, with the type of object created based on a key
* 
* @param K the key
* @param T the super class that all created classes derive from
*/
template<typename K, typename T>
class Factory { 
private: 
    typedef T *(*CreateObjectFunc)();

    /**
    * A map keys (K) to functions (CreateObjectFunc)
    * When creating a new type, we simply call the function with the required key
    */
    std::map<K, CreateObjectFunc> mObjectCreator;

    /**
    * Pointers to this function are inserted into the map and called when creating objects
    *
    * @param S the type of class to create
    * @return a object with the type of S
    */
    template<typename S> 
    static T* createObject(){ 
        return new S(); 
    }
public:

    /**
    * Registers a class to that it can be created via createObject()
    *
    * @param S the class to register, this must ve a subclass of T
    * @param id the id to associate with the class. This ID must be unique
    */ 
    template<typename S> 
    void registerClass(K id){ 
        if (mObjectCreator.find(id) != mObjectCreator.end()){ 
            //your error handling here
        }
        mObjectCreator.insert( std::make_pair<K,CreateObjectFunc>(id, &createObject<S> ) ); 
    }

    /**
    * Returns true if a given key exists
    *
    * @param id the id to check exists
    * @return true if the id exists
    */
    bool hasClass(K id){
        return mObjectCreator.find(id) != mObjectCreator.end();
    } 

    /**
    * Creates an object based on an id. It will return null if the key doesn't exist
    *
    * @param id the id of the object to create
    * @return the new object or null if the object id doesn't exist
    */
    T* createObject(K id){
        //Don't use hasClass here as doing so would involve two lookups
        typename std::map<K, CreateObjectFunc>::iterator iter = mObjectCreator.find(id); 
        if (iter == mObjectCreator.end()){ 
            return NULL;
        }
        //calls the required createObject() function
        return ((*iter).second)();
    }
};
    InformationsquelleAutor Yacoby
  2. 20

    La sérialisation est un sujet délicat en C++...

    Question rapide:

    • De sérialisation: courte durée de vie de la structure, un encodeur/décodeur
    • De messages: plus de vie, des encodeurs /décodeurs en plusieurs langues

    Les 2 sont utiles, et ont à leur utilisation.

    Coup de pouce.La sérialisation est le plus recommandé bibliothèque de sérialisation habituellement, bien que l'étrange choix de operator& qui sérialise ou désérialise en fonction de la const-ness est vraiment un abus de la surcharge d'opérateur pour moi.

    Pour la messagerie, je préfère suggérer Google Protocole Tampon. Ils offrent une propre syntaxe pour décrire le message et de générer des encodeurs et des décodeurs pour une grande variété de langues. Il y a aussi un autre avantage lorsque la performance est importante: elle permet aux paresseux de la désérialisation (c'est à dire uniquement la partie de la goutte à la fois) par la conception.

    De passer

    Maintenant, comme pour les détails de mise en œuvre, cela dépend vraiment de ce que vous souhaitez.

    • Vous avez besoin versioning, même pour les sérialisation, vous aurez probablement besoin de compatibilité descendante avec la version précédente de toute façon.
    • Vous peut ou ne peut pas, ont besoin d'un système de tag + factory. Il est seulement nécessaire pour les polymorphes de la classe. Et vous aurez besoin d'un factory par arbre d'héritage (kind) puis... le code peut être templatized bien sûr!
    • Pointeurs /Références vont vous mordre dans le cul... elles font référence à une position en mémoire que les changements après la désérialisation. J'ai l'habitude de choisir une tangente approche: chaque objet de chaque kind est donné un id, unique pour sa kind, et j'ai donc sérialiser les id plutôt qu'un pointeur. Certains framework gère aussi longtemps que vous n'avez pas de dépendance circulaire et de sérialiser les objets pointés /référencé en premier.

    Personnellement, j'ai essayé autant que je peux pour séparer le code de sérialisation /désérialisation du code qui s'exécute la classe. En particulier, j'essaie de l'isoler dans les fichiers source pour que les changements sur cette partie du code n'est pas d'anéantir la compatibilité binaire.

    Sur la gestion des versions

    J'ai l'habitude d'essayer de garder la sérialisation et la désérialisation d'une version de la proximité. Il est plus facile de vérifier qu'ils sont vraiment symétrique. J'ai aussi essayer de résumé la gestion des versions de manutention directement dans mon sérialisation cadre + un peu d'autres choses, parce que la SEC doit être respecté 🙂

    Sur la gestion des erreurs

    Pour faciliter la détection des erreurs, j'ai l'habitude d'utiliser une paire de "marqueurs" (spécial octets) pour séparer un objet à partir d'un autre. Il me permet de jeter immédiatement lors de la désérialisation, parce que je peux détecter un problème de désynchronisation des flux (c'est à dire, un peu mangé trop d'octets ou n'a pas mangé suffisamment).

    Si vous voulez permissive de la désérialisation, c'est à dire de la désérialisation du reste du flux, même si quelque chose a échoué avant, vous aurez à se déplacer vers octet-comte: chaque objet est précédé par sa octet-comte et de n'en manger tellement octet (et il est prévu de les manger tout). Cette approche est intéressante parce qu'elle permet partielle de la désérialisation: c'est à dire que vous pouvez enregistrer la partie du flux requis pour un objet et une seule désérialiser si nécessaire.

    De marquage (votre Id de classe) est utile ici, non pas (seulement) pour la distribution, mais simplement de vérifier que vous êtes en fait la désérialisation le bon type d'objet. Il permet aussi de jolis messages d'erreur.

    Voici quelques messages d'erreur /exception que vous pouvez souhaiter:

    • No version X for object TYPE: only Y and Z
    • Stream is corrupted: here are the next few bytes BBBBBBBBBBBBBBBBBBB
    • TYPE (version X) was not completely deserialized
    • Trying to deserialize a TYPE1 in TYPE2

    Remarque qu'aussi loin que je me souviens de la fois Boost.Serialization et protobuf vraiment aider pour l'erreur/la version de manutention.

    protobuf a quelques avantages trop, à cause de sa capacité de nidification messages:

    • l'octet-comte est naturellement pris en charge, ainsi que la gestion des versions
    • vous pouvez paresseux de la désérialisation (c'est à dire, stocker le message et seulement désérialiser si quelqu'un vous le demande)

    La contrepartie est qu'il est plus difficile de gérer le polymorphisme en raison de l'fixe le format du message. Vous devez soigneusement les concevoir pour qu'.

    InformationsquelleAutor Matthieu M.
  3. 6

    La sérialisation est malheureusement jamais être totalement indolore en C++, au moins pas dans un avenir prévisible, tout simplement parce que le C++ ne manque de la critique pour le langage qui permet la sérialisation possible dans d'autres langues : la réflexion. C'est, si vous créez une classe Foo, C++ n'a pas de mécanisme pour inspecter la classe par programmation à l'exécution pour déterminer quel membre de variables qu'il contient.

    Donc, il n'y a aucun moyen de créer généralisée de la sérialisation des fonctions. D'une façon ou d'une autre, vous avez à mettre en œuvre une spéciale de sérialisation de la fonction pour chaque classe. Coup de pouce.La sérialisation n'est pas différent, tout simplement, il vous offre un cadre commode et une belle série d'outils qui vous aideront à le faire.

    • Le C++ Middleware Écrivain automatise l'écriture de la sérialisation des fonctions.
    • En fait, le C++ a (un peu) au moment de la compilation de réflexion disponible par le biais de metatemplate bibliothèques. Il peut être ajouté à un abus de la directive de préprocesseur et Boost.La Fusion. Je ne voudrais pas aller dans cette voie si 😡
    InformationsquelleAutor Charles Salvia
  4. 6

    La réponse par Yacoby peut être étendu plus loin.

    Je crois que la sérialisation peut être mis en œuvre de manière similaire aux langages managés si l'on met en œuvre un système de réflexion.

    Pendant des années, nous avons été à l'aide de l'approche automatisée.

    J'ai été l'un des réalisateurs de travail C++ post-processeur et de la Réflexion de la bibliothèque: LSDC outil et Linderdaum de Base de Moteur (iObject + RTTI + Linker/Chargeur). Voir la source à http://www.linderdaum.com

    La fabrique de classe résumés le processus d'instanciation de classe.

    Pour initialiser les membres spécifiques, vous pouvez ajouter un peu intrusif RTTI et de générer automatiquement le chargement/enregistrement des procédures pour eux.

    Suppose, vous avez la iObject classe au sommet de votre hiérarchie.

    //Base class with intrusive RTTI
class iObject
{
public:
iMetaClass* FMetaClass;
};
///The iMetaClass stores the list of properties and provides the Construct() method:
//List of properties
class iMetaClass: public iObject
{
public:
virtual iObject* Construct() const = 0;
///List of all the properties (excluding the ones from base class)
vector<iProperty*> FProperties;
///Support the hierarchy
iMetaClass* FSuperClass;
///Name of the class
string FName;
};
//The NativeMetaClass<T> template implements the Construct() method.
template <class T> class NativeMetaClass: public iMetaClass
{
public:
virtual iObject* Construct() const
{
iObject* Res = new T();
Res->FMetaClass = this;
return Res;
}
};
//mlNode is the representation of the markup language: xml, json or whatever else.
//The hierarchy might have come from the XML file or JSON or some custom script
class mlNode {
public:
string FName;
string FValue;
vector<mlNode*> FChildren;
};
class iProperty: public iObject {
public:
///Load the property from internal tree representation
virtual void Load( iObject* TheObject, mlNode* Node ) const = 0;
///Serialize the property to some internal representation
virtual mlNode* Save( iObject* TheObject ) const = 0;
};
///function to save a single field
typedef mlNode* ( *SaveFunction_t )( iObject* Obj );
///function to load a single field from mlNode
typedef void ( *LoadFunction_t )( mlNode* Node, iObject* Obj );
//The implementation for a scalar/iObject field
//The array-based property requires somewhat different implementation
//Load/Save functions are autogenerated by some tool.
class clFieldProperty : public iProperty {
public:
clFieldProperty() {}
virtual ~clFieldProperty() {}
///Load single field of an object
virtual void Load( iObject* TheObject, mlNode* Node ) const {
FLoadFunction(TheObject, Node);
}
///Save single field of an object
virtual mlNode* Save( iObject* TheObject, mlNode** Result ) const {
return FSaveFunction(TheObject);
}
public:
//these pointers are set in property registration code
LoadFunction_t FLoadFunction;
SaveFunction_t FSaveFunction;
};
//The Loader class stores the list of metaclasses
class Loader: public iObject {
public:
void RegisterMetaclass(iMetaClass* C) { FClasses[C->FName] = C; }
iObject* CreateByName(const string& ClassName) { return FClasses[ClassName]->Construct(); }
///The implementation is an almost trivial iteration of all the properties
///in the metaclass and calling the iProperty's Load/Save methods for each field
void LoadFromNode(mlNode* Source, iObject** Result);
///Create the tree-based representation of the object
mlNode* Save(iObject* Source);
map<string, iMetaClass*> FClasses;
};

    Lorsque vous définissez la ConcreteClass dérivé de iObject, vous utilisez une extension, et le générateur de code de l'outil de produire la liste de sauvegarder/charger les procédures et le code d'enregistrement pour.

    Laissez-nous voir le code de cet exemple.

    Quelque part dans le cadre que nous avons un vide formel définir

    #define PROPERTY(...)
///vec3 is a custom type with implementation omitted for brevity
///ConcreteClass2 is also omitted
class ConcreteClass: public iObject {
public:
ConcreteClass(): FInt(10), FString("Default") {}
///Inform the tool about our properties
PROPERTY(Name=Int, Type=int,  FieldName=FInt)
///We can also provide get/set accessors
PROPERTY(Name=Int, Type=vec3, Getter=GetPos, Setter=SetPos)
///And the other field
PROPERTY(Name=Str, Type=string, FieldName=FString)
///And the embedded object
PROPERTY(Name=Embedded, Type=ConcreteClass2, FieldName=FEmbedded)
///public field
int FInt;
///public field
string FString;
///public embedded object
ConcreteClass2* FEmbedded;
///Getter
vec3 GetPos() const { return FPos; }
///Setter
void SetPos(const vec3& Pos) { FPos = Pos; }
private:
vec3 FPos;
};

    Généré automatiquement le code d'enregistrement serait:

    ///Call this to add everything to the linker
void Register_ConcreteClass(Linker* L) {
iMetaClass* C = new NativeMetaClass<ConcreteClass>();
C->FName = "ConcreteClass";
iProperty* P;
P = new FieldProperty();
P->FName = "Int";
P->FLoadFunction = &Load_ConcreteClass_FInt_Field;
P->FSaveFunction = &Save_ConcreteClass_FInt_Field;
C->FProperties.push_back(P);
... same for FString and GetPos/SetPos
C->FSuperClass = L->FClasses["iObject"];
L->RegisterClass(C);
}
//The autogenerated loaders (no error checking for brevity):
void Load_ConcreteClass_FInt_Field(iObject* Dest, mlNode* Val) {
dynamic_cast<ConcereteClass*>Object->FInt = Str2Int(Val->FValue);
}
mlNode* Save_ConcreteClass_FInt_Field(iObject* Dest, mlNode* Val) {
mlNode* Res = new mlNode();
Res->FValue = Int2Str( dynamic_cast<ConcereteClass*>Object->FInt );
return Res;
}
///similar code for FString and GetPos/SetPos pair with obvious changes

    Maintenant, si vous avez le JSON comme hiérarchique script

    Object("ConcreteClass") {
Int 50
Str 10
Pos 1.5 2.2 3.3
Embedded("ConcreteClass2") {
SomeProp Value
}
}

    L'éditeur de liens a pour but de résoudre toutes les classes et propriétés à Enregistrer/Charger des méthodes.

    Désolé pour le long post, la mise en œuvre pousse encore plus grande lorsque toutes les erreurs de manipulation est en.

    • J'ai vu plus laid... mais pas souvent. Je n'aime vraiment pas avoir une extra-pass dans le processus de compilation de la modification de mon code. Je ne me dérange pas d'avoir extra code ajouté (comme protobuf fichiers), mais lorsque l'extra pass trashes le fichier et vous vous retrouvez avec une erreur de compilation, le suivi de l'erreur est un cauchemar.
    • Eh bien, nous travaillons autour de l'absence des outils de la langue elle-même - cela ne peut être fait sans heurts. Il n'y a pas de code source bousiller - générés de la métainformation est également ajouté à la nouvelle source de fichiers. Si vous ne les incluez pas dans votre projet, il n'y a pas bousiller (et pas d'usines/de sérialisation tout de même). Les erreurs de compilation paraître compliqué (une fois que vous avez raté quelque chose dans la déclaration de la PROPRIÉTÉ), mais on peut s'habituer à eux comme nous le faisons tous avec le modèle de la classe des erreurs.
    • Je n'ai pas de promouvoir ce que LA solution. Sa vitesse ne peut pas comparer à la sérialisation binaire, de sorte qu'il est adapté pour les petites configs.
    • J'ai utilisé pour voir ce style de solution souvent...de retour dans les premiers jours de C++, en particulier pré-RTTI et pré-modèles et certainement avant la métaprogrammation. Très certainement, j'ai écrit quelque chose de similaire à plusieurs reprises. En fin de compte, après plusieurs années d'expérience, j'ai fait la conclusion personnelle que cette tente de prendre une solution qui fonctionne bien pour les langages dynamiques avec construit-dans la réflexion des capacités et des il jette dans une langue qui ne l'est pas. Vous êtes en fait la création d'un mini-système de type dynamique...et c'est pas C++.
    • Je ne dis pas que c'est mal, mais c'est un énorme fardeau à porter dans un système, et augmente considérablement la courbe d'apprentissage. Si vous allez loin, vous pourriez envisager de faire quelque chose comme IDL et à l'aide de l'OMG CDR. Oui, c'est un lourd fardeau, mais c'est au moins une norme lourd fardeau.
    • Nous allons juste accepter que c'est une "marche pour moi" solution 🙂 C'est un véritable fardeau et certainement c'est une ré-implémentation de la CLR/JVM-comme la réflexion du système. Bien sûr, il a ses racines dans le milieu des années Nonante 🙂 Quand il faut faire les choses simple et rapide, je n'emploient pas de C++ - je m'en tiens à C# ou Python ou tout ce qui convient à nos besoins. Cependant, de réutiliser le code et le lier à la dynamique des langues, le code automatisée post-processeur semble être utiles. De toute autre manière, c'est la chose du passé.
    • Oh, à propos de la "pré-métaprogrammation" chose. Supposons que nous avons inventé l'ensemble de modèles pour envelopper notre getters/setters et tous les sauver charge mess. Puis, une fois de plus, vous devez vous inscrire tout cela (pour ajouter un peu de "balisage" du code source, mais cette fois, il est juste en C++ natif). Avec le code généré est un jeu d'enfant. Et sur la courbe d'apprentissage. Oui, avec le dominant, le nombre de nouveau-âge développeurs utilisé pour la collecte des ordures et des environnements gérés le mise de C++ réflecteur est inutile. Vraiment, tout cela est juste un bien testé héritage.

    InformationsquelleAutor Viktor Latypov
  5. 5

    Peut-être que je ne suis pas malin, mais je pense que, finalement, le même type de code que vous avez écrit est écrit, tout simplement parce que le C++ n'est pas le moteur d'exécution des mécanismes pour faire quelque chose de différent. La question est de savoir si elle sera écrite sur mesure par un développeur, généré par modèle métaprogrammation (qui est ce que je soupçonne que boost.la sérialisation n'), ou généré via un outil externe comme un compilateur IDL/générateur de code.

    La question de savoir laquelle de ces trois mécanismes (et peut-être il y a d'autres possibilités, aussi) est quelque chose qui doit être évalué sur une base par projet.

    • Exactement ce que je voulais dire!
    InformationsquelleAutor Chris Cleeland
  6. 2

    Je suppose que la chose la plus proche à une norme serait Coup de pouce.La sérialisation. Je voudrais l'entendre et dans quel contexte vous avez appris que la chose à propos de l'Id de classe. Dans le cas de la sérialisation je peux vraiment penser à une autre façon (à moins bien sûr, vous connaissez le type que vous attendez lors de la désérialisation). Et aussi, Une taille unique ne convient pas à tous.

    InformationsquelleAutor Björn Pollex