Discussion :

[Invité]

Salut,
lors de la sérialisation je perd l'adresse des objets en sauvegardant les objets dans un fichier ou bien en les envoyant d'une machine à l'autre.

Et je crois pas que lorsque j'initialise un pointeur sur un objet d'une classe C appartenant à une classe A (en lisant l'objet C à partir d'un fichier), le pointeur sur ce même objet appartenant à la classe B est mis à jour.

Car il faut affecter le pointeur avec l'opérateur& pour lui assigner l'adresse de l'objet, hors, je n'ai pas l'adresse car elle a été détruite à la fermeture du programme ou bien elle est sur une autre machine.

Je me demande donc quel est le meilleur système pour ne pas désérialiser et sérialiser deux fois le même objet.

J'ai eu l'idée de faire une variable statique qui défini le nombre d'objets sérialiser, et j'incrémente cette variable à chaque fois que je sérialize un id, cet objet me sert d'id pour les objets et l'idée est la suivante :

Si deux objets ont la même adresse, alors, ils ont aussi le même id, si ils ont le même id j'écris juste l'id de l'objet dans le fichier, sinon, j'écris l'id et l'objet, ça m'évite de devoir sérializer deux fois le même objet, mais je dois aussi pouvoir vérifier si l'objet à déjà été sauvé, pour cela je sauvegarde l'id de l'objet et l'adresse de l'objet dans une map et je recherche l'adresse de l'objet que je veux sérialiser, comme ceci :

Code cpp :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
template <typename T>
    void operator& (T* data) {
        std::map<unsigned long long int, unsigned long long int>::iterator it = adresses.find(data);
        if (it != adresses.end()) {
            buffer<<it->second;
        } else {
            std::pair<unsigned long long int, unsigned long long int> newAddress (data, nbSerialized);
            adresses.insert(newAddress);
            buffer<<newAddress.second;
            buffer<<*data;
        }
        nbSerialized++;
    }

Lors de la lecture, je fais un peu l'inverse :

Je lis l'id de l'objet sérialisé, si il est présent dans la map, ça veut dire que l'objet à déjà été lu, donc, je recherche l'adresse de l'objet et j'affecte le pointeur, sinon, j'alloue l'objet, je le lis et je sauvegarde son id et son adresse dans la map :

Code cpp :

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
 
template <typename T>
    void operator& (T* data) {
        unsigned long long int id;
        buffer>>id;
        std::map<unsigned long long int, unsigned long long int>::iterator it = adresses.find(id);
        if (it != adresses.end()) {
            data = it->second;
        } else {
            data = new T();
            buffer>>*data;
            std::pair<unsigned long long int, unsigned long long int> (id, data);
            adresses.insert(id, data);
            nbDeserialized++;
        }
    }

Je comptes le nombre d'objets désérialisés ici pour voir si ça marche bien, si ça marche bien,le nombre d'objet désérialisé doit être différent du nombre d'id sérialiser si deu classe contiennent un pointeur vers le même objet.

[skeud]

Rien compris de ce que tu voulais faire ><.

Tu pourrais donné des exemple de code de tes objets? Qu'on sache comment tu organises tes données et donc te proposer une solution? .

[Médinoc]

Je pense que le mieux lors de la sérialisation est de maintenir une map dans ta classe sérialisatrice (ou classe d'archive), associant chaque pointeur à un ID que tu génères de manière incrémentale, pour chaque objet (et en donnant à chaque objet un ID).

La désérialisation est plus compliquée, par contre. Il faudra peut-être faire deux passes: Une pour la création des objets, une pour la résolution des associations.

De plus, si ton schéma de données peut inclure des tableaux d'objets (je dis bien des tableaux d'objets et non des tableaux de pointeurs sur objet, qui ne présentent pas ce problème), il faudra prendre plus que le pointeur dans ta clé, pour différentier "pointeur vers le tableau" et "pointeur vers le premier élément".

[Invité]

Bof, moi je fais tout en une fois même pour la désérialisation et pour les tableaux j'enregistre l'adresse de chaque élément :

Code cpp :

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
#ifndef ODFAEG_ARCHIVE
#define ODFAEG_ARCHIVE
#include <vector>
#include <map>
#include <ostream>
#include <istream>
#include <typeinfo>
#include "factory.h"
#include <iostream>
namespace odfaeg {
template<typename O>
class Serializer;
class OTextArchive {
public :
    OTextArchive(std::ostream& buffer) : buffer(buffer) {
    }
    template <typename T>
    void operator& (T& data) {
        buffer<<data;
    }
    template <typename T>
    void operator& (T* data) {
        std::map<unsigned long long int, unsigned long long int>::iterator it = adresses.find(data);
        if (it != adresses.end()) {
            buffer<<it->second;
        } else {
            std::pair<unsigned long long int, unsigned long long int> newAddress (data, nbSerialized);
            adresses.insert(newAddress);
            buffer<<newAddress.second;
            buffer<<*data;
        }
        nbSerialized++;
    }
    template <typename T>
    void operator& (std::vector<T>& data) {
        std::size_t size = data.size();
        buffer<<size;
        for (unsigned int i = 0; i < data.size(); i++)
            buffer<<data[i];
    }
    template <typename T>
    void operator& (std::vector<T*> data) {
        std::size_t size = data.size();
        buffer<<size;
        for (unsigned int i = 0; i < data.size(); i++)
            buffer<<data[i];
    }
    template <typename O>
    void save (O* object, void(O::*func)(OTextArchive&)) {
        (object->*func)(*this);
    }
    template <typename B, typename D>
    void save (B* base, void(D::*func)(OTextArchive&)) {
        (static_cast<D*>(base)->*func)(*this);
    }
    template <typename C>
    void operator<<(Serializer<C>* serializer) {
        void(C::*func)(OTextArchive&);
        serializer->getSerializeFunc(&func);
        C* object = static_cast<C*>(serializer);
        save(object, func);
        serializer->onSave();
    }
    template <typename C>
    void operator<<(Serializer<C>& serializer) {
        void(C::*func)(OTextArchive&);
        serializer.getSerializeFunc(&func);
        C* object = static_cast<C*>(&serializer);
        save(object, func);
        serializer.onSave();
    }
 
private :
    std::ostream& buffer;
    std::map<unsigned long long int, unsigned long long int> adresses;
    static unsigned long long int nbSerialized;
};
class ITextArchive {
public :
    ITextArchive (std::istream& buffer) : buffer(buffer) {
    }
    template <typename T>
    void operator& (T& data) {
        buffer>>data;
    }
    template <typename T>
    void operator& (T* data) {
        unsigned long long int id;
        buffer>>id;
        std::map<unsigned long long int, unsigned long long int>::iterator it = adresses.find(id);
        if (it != adresses.end()) {
            data = it->second;
        } else {
            data = new T();
            buffer>>*data;
            std::pair<unsigned long long int, unsigned long long int> (id, data);
            adresses.insert(id, data);
            nbDeserialized++;
        }
    }
    template <typename T>
    void operator& (std::vector<T>& data) {
        std::size_t size;
        buffer>>size;
        for (unsigned int i = 0; i < size; i++)
            buffer>>data[i];
    }
    template <typename T>
    void operator& (std::vector<T*> data) {
        std::size_t size;
        buffer>>size;
        for (unsigned int i = 0; i < size; i++) {
            T* vi;
            buffer>>vi;
            data.push_back(vi);
        }
    }
    template <typename O>
    void load (O* object, void(O::*func)(ITextArchive&)) {
        (object->*func)(*this);
    }
    template <typename B, typename D>
    void load (B* base, void(D::*func)(ITextArchive&)) {
        (static_cast<D*>(base)->*func)(*this);
    }
    template <typename C>
    void operator>>(Serializer<C>* serializer) {
        void(C::*func)(ITextArchive&);
        serializer->getSerializeFunc(&func);
        C* object = static_cast<C*>(serializer);
        load(object, func);
        serializer->onSave();
    }
    template <typename C>
    void operator>>(Serializer<C>& serializer) {
        void(C::*func)(ITextArchive&);
        serializer.getSerializeFunc(&func);
        C* object = static_cast<C*>(&serializer);
        load(object, func);
        serializer.onSave();
    }
 
private :
    std::istream& buffer;
    std::map<unsigned long long int, unsigned long long int> adresses;
    static unsigned long long int nbDeserialized;
};
}
#endif // ODFAEG_ARCHIVE

Par contre je ne sais pas si ça marche, à vrai dire je n'ai pas encore testé je suis en plein sur la dernière partie de mon moteur de jeux qui comporte sur la sauvegarde et le transfert de données en réseau, et là j'essaye de sérialiser toutes les classes de manière récursive car les entités de mon jeux peuvent être complexe et contenir des hiérarchie de volumes englobants...

[Médinoc]

Une hiérarchie, ou tout graphe non-orienté sans cycle, peut être sérialisé(e) par simple récursivité. C'est quand on a de la duplication ou des cycles que ça devient compliqué et que la récursivité ne suffit plus.

[Invité]

Bon j'ai testé cela et ça fonctionne :

Lors de l'écriture : je vérifie si l'adresse de l'objet n'est pas présente dans la std::map, si elle ne l'est pas, j'écris l'id de l'objet et son contenu dans le fichier et j'ajoute l'id et l'adresse de l'objet dans la std::map, sinon, j'écris juste l'id de l'objet. (J'incrémente l'id de l'objet à chaque fois que j'écris un nouvel objet)

Lors de la lecture : je vérifie si l'id de l'objet n'est pas présent dans la map, si il ne l'est pas, je crée un nouvel objet, je lis son id et son contenu et j'ajoute l'id et l'adresse de l'objet dans la std::map.

Si l'id est déjà présent dans la std::map ça veut dire que l'objet a déjà été lu une fois donc je cherche son adresse dans la std::map et je lui donne la bonne adresse ce qui me donne ceci au niveau du code :

Ecriture :

Code cpp :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
template <class O,
          class = decltype(std::declval<O&>().serialize(std::declval<OTextArchive&>()))>
    void operator() (O* object) {
        std::map<unsigned long long int, unsigned long long int>::iterator it = adresses.find(reinterpret_cast<unsigned long long int>(object));
        if (it != adresses.end()) {
            buffer<<it->second;
        } else {
            std::pair<unsigned long long int, unsigned long long int> newAddress (reinterpret_cast<unsigned long long int>(object), nbSerialized);
            adresses.insert(newAddress);
            buffer<<newAddress.second;
            object->serialize(*this);
            nbSerialized++;
        }       
    }

Et lecture :

Code cpp :

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
 
 template <class O,
          class = decltype(std::declval<O&>().serialize(std::declval<ITextArchive&>()))>
    void operator() (O* object) {
        unsigned long long int id;
        buffer>>id;
        std::map<unsigned long long int, unsigned long long int>::iterator it = adresses.find(id);
        if (it != adresses.end()) {
            object = reinterpret_cast<O*>(it->second);
        } else {
            object = new O();
            object->serialize(*this);
            std::pair<unsigned long long int, unsigned long long int> newAddress (id, reinterpret_cast<unsigned long long int>(object));
            adresses.insert(newAddress);
            nbDeserialized++;
        }
    }