C++ Boost sérialisation sérialisation templated classes dérivées

Question

je voudrais sérialiser une classe avec un attribut comme une liste de pointeurs sur une classe générique

C'est la classe parente dont dérive la classe générique:

class Base{ 

    public : 

     friend class boost::serialization::access; 

     virtual ~Base(){} 

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

     virtual string Getid() = 0 ; 

}; 

La classe générique:

template<typename T> 
class GenericBase : public Base 
{ 
    public: 

     friend class boost::serialization::access; 

     GenericBase<T>(string id){} 
     ~GenericBase(){} 

     string id; 

     vector<T> data 

     template<class Archive> 
     void serialize(Archive & ar, const unsigned int version) 
     { 
      ar & boost::serialization::base_object<Base>(*this); 
      ar & BOOST_SERIALIZATION_NVP(id); 
      ar & BOOST_SERIALIZATION_NVP(data); 

     } 

     string Getid() { return id; } 

}; 

La classe je veux sérialisation

class Use 
{ 
    public: 

     friend class boost::serialization::access; 

     int Id; 

     map<string, Base*> BaseDatas; 

     Use(); 
     ~Use(); 

}; 

Ainsi, après avoir lu la doc sérialisation boost (http://www.boost.org/doc/libs/1_43_0/libs/serialization/doc/serialization.html#derivedpointers), j'ai essayé cela dans le code de sérialisation:

main(){ 

    Use u = Use(); 

    std::ofstream ofs(filename, ios::binary); 

    // save data to archive 

    boost::archive::binary_oarchive oa(ofs); 

    oa.template register_type<GenericBase<Type1> >(); 
    oa.template register_type<GenericBase<Type2> >(); 
    oa.template register_type<GenericBase<Type3> >(); 

    oa<<u; 

} 

J'ai reçu un message,

error: 'template' (as a disambiguator) is only allowed within templates

, donc j'ai remplacé

oa.template register_type >();

par

oa.register_type();

cela a fonctionné et moi avons été en mesure d'enregistrer dans le texte et en binaire (i vérifié les données)

pour le chargement maintenant, je viens d'utiliser ces lignes:

main(){ 

    Use u; 

    std::ifstream ifs(filename, ios::binary); 

    // load data 

    ia.register_type<GenericBase<Type1> >(); 

    boost::archive::binary_iarchive ia(ifs); 

    ia>>u; 

} 

il me jeté une erreur:

error: no matching function for call to 'GenericBase::GenericBase()'

quelqu'un m'a dit que je devais remplacer 2 méthodes sauvegarder et charger comme dans cet exemple http://www.boost.org/doc/libs/1_43_0/libs/serialization/doc/serialization.html#constructors

namespace boost { namespace serialization { 
template<class Archive> 
inline void save_construct_data(
    Archive & ar, const my_class * t, const unsigned int file_version) 
    { 
     // save data required to construct instance 
     ar << t->m_attribute; 
    } 

template<class Archive> 
inline void load_construct_data(
    Archive & ar, my_class * t, const unsigned int file_version) 
    { 
     // retrieve data from archive required to construct new instance 
     int attribute; 
     ar >> attribute; 
     // invoke inplace constructor to initialize instance of my_class 
     ::new(t)my_class(attribute); 
    } 
}} // namespace ... 

mais où je dois les définir? En déclaration de la classe Use? Et comment puis-je traiter avec le membre

map<string, Base*> BaseDatas; 

?

Merci pour votre aide;)

Answer 1

but where do I have to define them ?

Vous pouvez les définir dans l'un de vos têtes

And how do I deal with the member...

Je pense que vous pouvez obtenir des pointeurs coup de pouce à suivre en utilisant BOOST_CLASS_TRACKING ...

http://www.boost.org/doc/libs/1_42_0/libs/serialization/doc/special.html#objecttracking

Answer 2

Il est plus facile de commenter si vous pro Vidé un exemple de code à défaut de travail (couper-coller), avec des données factices ...

Mais je tente de répondre de toute façon ...Boost.serialization tente d'appeler le constructeur par défaut GenericBases, mais échoue puisque vous ne le fournissez pas. Boost.serialisation crée d'abord votre objet (ou tente maintenant), puis lit le fichier et définit les variables.

Vous pouvez essayer de déclarer un constructeur par défaut protégé, auquel boost devrait avoir accès.