Sérialization, templates et pointeurs

Version imprimable

Bonjour, je souhaite sérialiser une classe avec en attribut une liste de pointeurs sur une classe générique

Tout d'abord la classe mère dont dérive la classe générique

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
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 :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
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 que je veux sérialiser :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
class Use
{
	public:
 
            friend class boost::serialization::access;
 
            int Id;
 
            map<string, Base*> BaseDatas;
 
            Use();
            ~Use();
 
};

je crois qu'il faut enregistrer auprès des flux output et input chaque GenericBase<T>spécialisé c'est ça ?

09/06/2010, 14h06
Nogane
Bonjour,
La solution de base en effectivement d'enregistrer les type dérivés das les archives:
Code:

1 2 3 4 5 6 7 8 main(){ ... ar.template register_type<derived_one>(); ar.template register_type<derived_two>(); base *b; ... ar & b; }
Mais on peut aussi utiliser la macro BOOST_CLASS_EXPORT_GUID ou BOOST_CLASS_EXPORT.

Tout est expliqué ici:
http://www.boost.org/doc/libs/1_43_0...l#registration

donc ma classe Use sérializable ressemblerait à ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
 
class Use
{
	public:
 
            friend class boost::serialization::access;
 
            int Id;
 
            map<string, Base*> BaseDatas;
 
            template<class Archive>
            void serialize(Archive & ar, const unsigned int version)
            {
                ar & Id;
 
                ar.template register_type<GenericBase>();
 
                ar & BaseDatas;
 
            }
 
            Use();
            ~Use();
 
};

et l'enregistrement à :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
main(){
 
   Use *u = new Use();
 
    std::ofstream ofs(filename, ios::binary);
 
    // save data to archive
 
        boost::archive::binary_oarchive oa(ofs);
 
        oa<<u;
 
}

mais là il me sort "error: no matching function for call to 'boost::archive::binary_oarchive::register_type()'"

Non, je verrais plutot les chose comme ca:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
main(){
 
   Use *u = new Use();
 
    std::ofstream ofs(filename, ios::binary);
 
    // save data to archive
 
    boost::archive::binary_oarchive oa(ofs);
 
    //Le register_type est fait AVANT le lancer la sérialisation.
    //De plus il est fait sur chaque type enfants pouvant être instanciés.
    ar.template register_type<GenericBase<Type1> >();
    ar.template register_type<GenericBase<Type2> >();
    ar.template register_type<GenericBase<Type3> >();
 
    oa<<u;
 
}

09/06/2010, 21h00
coda_blank

oui mais d'où sort le ar ? on est bien dans le main ? :?
09/06/2010, 21h55
Nogane

Oups, c'est juste une erreur de copier/coller, il faut lire oa, et pas ar.
13/06/2010, 21h58
coda_blank

bon j'ai retenté avec oa.template register_type<GenericBase<float> >();

et donc :

Code:

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

même chose pour oa.template register_type(static_cast<GenericBase *>(NULL));
14/06/2010, 15h46
Nogane

Ok, alors avez vous essayé sans le mot clef "template"?
Genre:

Code:

oa.register_type<GenericBase<float> >();

J'ai du laisser ce problème de coté quelques temps, mais me revoilà

j'ai fait comme vous avez dit et j'ai réussi à sauver en text et en binaire

le problème se situe maintenant au niveau du chargement

donc pour rappel l'enregistrement donne
Code:

1 2 3 4 5 6 7 8 9 10 11 Use *u = new Use(); std::ofstream ofs(filename, ios::binary); // save data to archive boost::archive::binary_oarchive oa(ofs); oa.register_type<GenericBase<float> >(); oa<<u;
et le chargement :
Code:

1 2 3 4 5 6 7 8 9 Use *u; std::ifstream ifs(filename, ios::binary); // save data to archive boost::archive::binary_iarchive ia(ifs); ia>>u;
compilation sans problème par contre à l'exécution, erreur :
Code:

1 2 3 4 5 Assertion failed: new_cid == cid, file libs\serialization\src\basic_iarchive.cpp, line 450 This application has requested the Runtime to terminate it in an unusual way. Please contact the application's support team for more information.
maintenant avec Use u et non plus Use* u :
Code:

1 2 3 4 5 6 terminate called after throwing an instance of 'boost::archive::archive_exception' what(): stream error This application has requested the Runtime to terminate it in an unusual way. Please contact the application's support team for more information.
si dans la classe Use je mets en commentaire

Code:

ar & BaseDatas;

, le problème persiste, mais si en plus de ça je mets en commentaire

Code:

oa.register_type<GenericBase<float> >();

alors plus d'erreur (mais uniquement pour Use* u);

j'ai essayé d'ajouter

Code:

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

au chargement avec en retour ceci à la compilation :

Code:

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

en fait

Code:

oa.register_type<GenericBase<float> >();

me permet de réaliser la sauvegarde mais fait obstacle au chargement

:?

15/07/2010, 21h54
Nogane

Bonsoir,
Le register_type est effectivement nécessaire au changement aussi.
Le problème que vous avez est du à l'absence de constructeur par défaut dans la class GenericBase<float>. Comme le dit le message:

Citation:

Code:

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

Il faut bien comprendre que la deserialisation de pointeur implique un 'new' lors du chargement.

Il y as deux solution au problème:
- Donner un constructeur par defaut a la class gérée par pointeur.(Mais ce n'est pas toujours judicieux, ni possible)
- Dire a boost comment créer un objet de ce type. Un exemple ici:
http://www.boost.org/doc/libs/1_43_0...l#constructors

donc je dois redéfinir deux méthode save et load telles que présentées dans cet exemple

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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 ou dois je le faire ? dans la déclaration de GenericBase, dans celle de Use ?

Et comment faire avec le membre map<string, Base*> BaseDatas; ?