Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Samuel Krempp
le Thursday 02 October 2003 16:53, écrivit :
Je cherche des informations sur le principe de serialisation. Non pas sur la mise en pratique en MFC mais sur son codage integral.
sur le principe de la sérialisation, ou de la sérialisation telle que pratiquée 'en MFC' (qui serait HS, et done je ne connais rien) ?
en toute généralité, le principe est extrêmement simple : il s'agit de créer une suite d'octets à partir d'un objet, et d'être capable plus tard de faire l'inverse (re-créer l'objet à partir de la suite d'octets).
dans le détail, il n'y a pas de solution universelle. il y a des méthodes qui permettent de sérialiser des objets à partir de la seule liste de ses données membres sous certaines restrictions (le cas échéant, à partir de code custom ajouté par l'utilisateur)
Pour des nombres et autres objets à sémantique de valeur, il y a des solutions conceptuellement très simples qui permette de sérialiser sans trop faire de choses soi-même, ie juste fournir une fonction membre qui liste les membres données. ce qui peut s'exprimer par exemple avec le draft de boost::serialization :
class Toto { public: int i,j; template<class Archiver> void describe(Archiver& ar) { ar & i & j; } }; (ça suffit pour que la classe soit sérialisable)
Pour des pointeurs vers objets appartenant à une hiérarchie de classe contenant éventuellement des pointeurs vers d'autres objets formant éventuellement un graphe avec cycles, ça commence à devenir un peu dur mais je crois que ce draft permet encore de sérializer simplement à partir d'une fonction listant les données membres, comme celle de Toto.
Pour une classe completement zarbe, il pourrait être nécessaire de se taper soi-même le code capable d'en sérialiser un objet au lieu de juste fournir une fonction chargée de lister les membres de données.
exemple : Toto { int *p; public: Toto() : p( (new int(0)) + 2) {} [..]
ne va pas être bien sérialisée par la simple fonction canonique .. (juste pour bien souligner que dans l'absolu, il ne suffit pas de connaitre toutes les données membres d'un objet pour le sérialiser)
-- Sam
le Thursday 02 October 2003 16:53, unknow@unk.fr écrivit :
Je cherche des informations sur le principe de serialisation. Non pas sur
la mise en pratique en MFC mais sur son codage integral.
sur le principe de la sérialisation, ou de la sérialisation telle que
pratiquée 'en MFC' (qui serait HS, et done je ne connais rien) ?
en toute généralité, le principe est extrêmement simple : il s'agit de créer
une suite d'octets à partir d'un objet, et d'être capable plus tard de
faire l'inverse (re-créer l'objet à partir de la suite d'octets).
dans le détail, il n'y a pas de solution universelle.
il y a des méthodes qui permettent de sérialiser des objets à partir de la
seule liste de ses données membres sous certaines restrictions (le cas
échéant, à partir de code custom ajouté par l'utilisateur)
Pour des nombres et autres objets à sémantique de valeur, il y a des
solutions conceptuellement très simples qui permette de sérialiser sans
trop faire de choses soi-même, ie juste fournir une fonction membre qui
liste les membres données. ce qui peut s'exprimer par exemple avec le draft
de boost::serialization :
class Toto {
public:
int i,j;
template<class Archiver>
void describe(Archiver& ar) {
ar & i & j;
}
};
(ça suffit pour que la classe soit sérialisable)
Pour des pointeurs vers objets appartenant à une hiérarchie de classe
contenant éventuellement des pointeurs vers d'autres objets formant
éventuellement un graphe avec cycles, ça commence à devenir un peu dur mais
je crois que ce draft permet encore de sérializer simplement à partir d'une
fonction listant les données membres, comme celle de Toto.
Pour une classe completement zarbe, il pourrait être nécessaire de se taper
soi-même le code capable d'en sérialiser un objet au lieu de juste fournir
une fonction chargée de lister les membres de données.
exemple :
Toto {
int *p;
public:
Toto() : p( (new int(0)) + 2) {}
[..]
ne va pas être bien sérialisée par la simple fonction canonique ..
(juste pour bien souligner que dans l'absolu, il ne suffit pas de connaitre
toutes les données membres d'un objet pour le sérialiser)
Je cherche des informations sur le principe de serialisation. Non pas sur la mise en pratique en MFC mais sur son codage integral.
sur le principe de la sérialisation, ou de la sérialisation telle que pratiquée 'en MFC' (qui serait HS, et done je ne connais rien) ?
en toute généralité, le principe est extrêmement simple : il s'agit de créer une suite d'octets à partir d'un objet, et d'être capable plus tard de faire l'inverse (re-créer l'objet à partir de la suite d'octets).
dans le détail, il n'y a pas de solution universelle. il y a des méthodes qui permettent de sérialiser des objets à partir de la seule liste de ses données membres sous certaines restrictions (le cas échéant, à partir de code custom ajouté par l'utilisateur)
Pour des nombres et autres objets à sémantique de valeur, il y a des solutions conceptuellement très simples qui permette de sérialiser sans trop faire de choses soi-même, ie juste fournir une fonction membre qui liste les membres données. ce qui peut s'exprimer par exemple avec le draft de boost::serialization :
class Toto { public: int i,j; template<class Archiver> void describe(Archiver& ar) { ar & i & j; } }; (ça suffit pour que la classe soit sérialisable)
Pour des pointeurs vers objets appartenant à une hiérarchie de classe contenant éventuellement des pointeurs vers d'autres objets formant éventuellement un graphe avec cycles, ça commence à devenir un peu dur mais je crois que ce draft permet encore de sérializer simplement à partir d'une fonction listant les données membres, comme celle de Toto.
Pour une classe completement zarbe, il pourrait être nécessaire de se taper soi-même le code capable d'en sérialiser un objet au lieu de juste fournir une fonction chargée de lister les membres de données.
exemple : Toto { int *p; public: Toto() : p( (new int(0)) + 2) {} [..]
ne va pas être bien sérialisée par la simple fonction canonique .. (juste pour bien souligner que dans l'absolu, il ne suffit pas de connaitre toutes les données membres d'un objet pour le sérialiser)
-- Sam
unknow
Mais alors quelles sont les noms des methodes mises en oeuvre ? Connaissant le nom de ces dernieres, je pourrai sans doute trouver plus d'info sur le NET.
Y-a-til des liens vers les infos theoriques sur la serialisation ?
Merci
"Samuel Krempp" a écrit dans le message news: 3f7cb478$0$10405$
le Thursday 02 October 2003 16:53, écrivit :
Je cherche des informations sur le principe de serialisation. Non pas sur
la mise en pratique en MFC mais sur son codage integral.
sur le principe de la sérialisation, ou de la sérialisation telle que pratiquée 'en MFC' (qui serait HS, et done je ne connais rien) ?
en toute généralité, le principe est extrêmement simple : il s'agit de créer
une suite d'octets à partir d'un objet, et d'être capable plus tard de faire l'inverse (re-créer l'objet à partir de la suite d'octets).
dans le détail, il n'y a pas de solution universelle. il y a des méthodes qui permettent de sérialiser des objets à partir de la seule liste de ses données membres sous certaines restrictions (le cas échéant, à partir de code custom ajouté par l'utilisateur)
Pour des nombres et autres objets à sémantique de valeur, il y a des solutions conceptuellement très simples qui permette de sérialiser sans trop faire de choses soi-même, ie juste fournir une fonction membre qui liste les membres données. ce qui peut s'exprimer par exemple avec le draft
de boost::serialization :
class Toto { public: int i,j; template<class Archiver> void describe(Archiver& ar) { ar & i & j; } }; (ça suffit pour que la classe soit sérialisable)
Pour des pointeurs vers objets appartenant à une hiérarchie de classe contenant éventuellement des pointeurs vers d'autres objets formant éventuellement un graphe avec cycles, ça commence à devenir un peu dur mais
je crois que ce draft permet encore de sérializer simplement à partir d'une
fonction listant les données membres, comme celle de Toto.
Pour une classe completement zarbe, il pourrait être nécessaire de se taper
soi-même le code capable d'en sérialiser un objet au lieu de juste fournir une fonction chargée de lister les membres de données.
exemple : Toto { int *p; public: Toto() : p( (new int(0)) + 2) {} [..]
ne va pas être bien sérialisée par la simple fonction canonique .. (juste pour bien souligner que dans l'absolu, il ne suffit pas de connaitre
toutes les données membres d'un objet pour le sérialiser)
-- Sam
Mais alors quelles sont les noms des methodes mises en oeuvre ?
Connaissant le nom de ces dernieres, je pourrai sans doute trouver plus
d'info sur le NET.
Y-a-til des liens vers les infos theoriques sur la serialisation ?
Merci
"Samuel Krempp" <krempp@crans.truc.en.trop.ens-cachan.fr> a écrit dans le
message news: 3f7cb478$0$10405$626a54ce@news.free.fr...
le Thursday 02 October 2003 16:53, unknow@unk.fr écrivit :
Je cherche des informations sur le principe de serialisation. Non pas
sur
la mise en pratique en MFC mais sur son codage integral.
sur le principe de la sérialisation, ou de la sérialisation telle que
pratiquée 'en MFC' (qui serait HS, et done je ne connais rien) ?
en toute généralité, le principe est extrêmement simple : il s'agit de
créer
une suite d'octets à partir d'un objet, et d'être capable plus tard de
faire l'inverse (re-créer l'objet à partir de la suite d'octets).
dans le détail, il n'y a pas de solution universelle.
il y a des méthodes qui permettent de sérialiser des objets à partir de la
seule liste de ses données membres sous certaines restrictions (le cas
échéant, à partir de code custom ajouté par l'utilisateur)
Pour des nombres et autres objets à sémantique de valeur, il y a des
solutions conceptuellement très simples qui permette de sérialiser sans
trop faire de choses soi-même, ie juste fournir une fonction membre qui
liste les membres données. ce qui peut s'exprimer par exemple avec le
draft
de boost::serialization :
class Toto {
public:
int i,j;
template<class Archiver>
void describe(Archiver& ar) {
ar & i & j;
}
};
(ça suffit pour que la classe soit sérialisable)
Pour des pointeurs vers objets appartenant à une hiérarchie de classe
contenant éventuellement des pointeurs vers d'autres objets formant
éventuellement un graphe avec cycles, ça commence à devenir un peu dur
mais
je crois que ce draft permet encore de sérializer simplement à partir
d'une
fonction listant les données membres, comme celle de Toto.
Pour une classe completement zarbe, il pourrait être nécessaire de se
taper
soi-même le code capable d'en sérialiser un objet au lieu de juste fournir
une fonction chargée de lister les membres de données.
exemple :
Toto {
int *p;
public:
Toto() : p( (new int(0)) + 2) {}
[..]
ne va pas être bien sérialisée par la simple fonction canonique ..
(juste pour bien souligner que dans l'absolu, il ne suffit pas de
connaitre
toutes les données membres d'un objet pour le sérialiser)
Mais alors quelles sont les noms des methodes mises en oeuvre ? Connaissant le nom de ces dernieres, je pourrai sans doute trouver plus d'info sur le NET.
Y-a-til des liens vers les infos theoriques sur la serialisation ?
Merci
"Samuel Krempp" a écrit dans le message news: 3f7cb478$0$10405$
le Thursday 02 October 2003 16:53, écrivit :
Je cherche des informations sur le principe de serialisation. Non pas sur
la mise en pratique en MFC mais sur son codage integral.
sur le principe de la sérialisation, ou de la sérialisation telle que pratiquée 'en MFC' (qui serait HS, et done je ne connais rien) ?
en toute généralité, le principe est extrêmement simple : il s'agit de créer
une suite d'octets à partir d'un objet, et d'être capable plus tard de faire l'inverse (re-créer l'objet à partir de la suite d'octets).
dans le détail, il n'y a pas de solution universelle. il y a des méthodes qui permettent de sérialiser des objets à partir de la seule liste de ses données membres sous certaines restrictions (le cas échéant, à partir de code custom ajouté par l'utilisateur)
Pour des nombres et autres objets à sémantique de valeur, il y a des solutions conceptuellement très simples qui permette de sérialiser sans trop faire de choses soi-même, ie juste fournir une fonction membre qui liste les membres données. ce qui peut s'exprimer par exemple avec le draft
de boost::serialization :
class Toto { public: int i,j; template<class Archiver> void describe(Archiver& ar) { ar & i & j; } }; (ça suffit pour que la classe soit sérialisable)
Pour des pointeurs vers objets appartenant à une hiérarchie de classe contenant éventuellement des pointeurs vers d'autres objets formant éventuellement un graphe avec cycles, ça commence à devenir un peu dur mais
je crois que ce draft permet encore de sérializer simplement à partir d'une
fonction listant les données membres, comme celle de Toto.
Pour une classe completement zarbe, il pourrait être nécessaire de se taper
soi-même le code capable d'en sérialiser un objet au lieu de juste fournir une fonction chargée de lister les membres de données.
exemple : Toto { int *p; public: Toto() : p( (new int(0)) + 2) {} [..]
ne va pas être bien sérialisée par la simple fonction canonique .. (juste pour bien souligner que dans l'absolu, il ne suffit pas de connaitre
toutes les données membres d'un objet pour le sérialiser)
