Discussion :

[coda_blank]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 ?

[Nogane]

Bonjour,
La solution de base en effectivement d'enregistrer les type dérivés das les archives:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[coda_blank]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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()'"

[Nogane]

Non, je verrais plutot les chose comme ca:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
 
}

[coda_blank]

oui mais d'où sort le ar ? on est bien dans le main ?

[Nogane]

Oups, c'est juste une erreur de copier/coller, il faut lire oa, et pas ar.

[coda_blank]

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

et donc :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

même chose pour oa.template register_type(static_cast<GenericBase *>(NULL));

[Nogane]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[coda_blank]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

ar & BaseDatas;

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

j'ai essayé d'ajouter

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

au chargement avec en retour ceci à la compilation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

en fait

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

[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:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[coda_blank]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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; ?