Comment désérialisez-vous une classe dérivée des données sérialisées?

Question

Comment désérialisez-vous une classe dérivée des données sérialisées? Ou peut-être devrais-je dire, existe-t-il un meilleur moyen de «désérialiser» les données dans les classes dérivées? Par exemple, supposons que vous ayez une classe de base virtuelle pure (B) héritée par trois autres classes, X, Y et Z. De plus, nous avons une méthode, serialize(), qui traduira X: B, Y: B et Z: B en données sérialisées. De cette façon, il peut être zappé sur un socket, un tube nommé, etc. vers un processus distant.

Le problème que j'ai, est, comment pouvons-nous créer un objet approprié à partir des données sérialisées?

La seule solution que je peux trouver est d'inclure un identifiant dans les données sérialisées qui indique le type d'objet dérivé final. Lorsque le destinataire analyse d'abord le champ de type dérivé à partir des données sérialisées, puis utilise une instruction switch (ou une sorte de logique de ce type) pour appeler le constructeur approprié.

Par exemple:

B deserialize(serial_data) 
{ 
    parse the derived type from the serial_data 

    switch (derived type) 
     case X 
      return X(serial_data) 
     case Y 
      return Y(serial_data) 
     case Z 
      return Z(serial_data) 
} 

donc après avoir appris le type d'objet dérivé nous invoquons le constructeur de type dérivé de approprié.

Cependant, cela semble gênant et lourd. J'espère qu'il y a une façon plus éloquente de le faire. Y a-t-il?

Answer 1

En fait, c'est un problème plus général que la sérialisation, appelé Virtual Constructor.

L'approche traditionnelle est un Factory qui, basé sur un ID, renvoie le type dérivé droit. Il y a deux solutions:

• la méthode switch comme vous avez remarqué, mais vous devez allouer sur le tas
• la méthode prototype

La méthode prototype va comme ceci:

// Cloneability 
class Base 
{ 
public: 
    virtual Base* clone() const = 0; 
}; 

class Derived: public Base 
{ 
public: 
    virtual Derived* clone() const { return new Derived(*this); } 
}; 

// Factory 
class Factory 
{ 
public: 
    Base* get(std::string const& id) const; 
    void set(std::string const& id, Base* exemplar); 

private: 
    typedef std::map < std::string, Base* > exemplars_type; 
    exemplars_type mExemplars; 
}; 

Il est quelque peu traditionnel de faire du Factory un singleton, mais c'est une toute autre affaire.

Pour la désérialisation proprement dite, il est plus facile de faire appel à une méthode virtuelle deserialize pour appeler l'objet.

EDIT: Comment fonctionne l'usine?

En C++, vous ne pouvez pas créer un type que vous ne connaissez pas.L'idée ci-dessus est donc que la tâche de construction d'un objet Derived est donnée à la classe Derived, au moyen de la méthode clone.

Vient ensuite le Factory. Nous allons utiliser un map qui va associer un "tag" (par exemple "Derived") à une instance d'un objet (disons Derived ici).

Factory factory; 
Derived derived; 
factory.set("Derived", &derived); 

Maintenant, quand nous voulons créer un objet type que nous ne savons pas au moment de la compilation (parce que le type est décidé à la volée), on passe une étiquette à l'usine et demander un objet revenir.

std::unique_ptr<Base> base = factory.get("Derived"); 

Sous le couvert, le Factory trouvera le Base* associé à l'étiquette "Derived" et invoquer la méthode clone de l'objet. Cela crée (ici) un objet de type d'exécution Derived.

Nous pouvons le vérifier en utilisant l'opérateur typeid:

assert(typeid(base) == typeid(Derived)); 

Answer 2

 
inmemory: 
-------- 
type1 { 
    chartype a; 
    inttype b; 
}; 
serialize(new type1()); 

serialized(ignore { and ,): 
--------------------------- 
type1id,len{chartypeid,adata,inttypeid,bdata} 

je suppose, dans un protocole de sérialisation idéal, tous les types non primitifs doivent être préfixé avec typeid, len. Même si vous sérialisez un seul type qui n'est pas dérivé de quelque chose, vous devez ajouter un identifiant de type, car l'autre extrémité doit savoir quel type obtient (indépendamment de la structure d'héritage). Vous devez donc mentionner les identifiants de classes dérivées dans la sérialisation, car, logiquement, ce sont des types différents. Corrigez-moi si je me trompe.