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.