Appel auto de méthodes sur des methodes virtuelles

Bonjour j'aurais besoin d'une méthodologie pour résoudre un petit probleme.
En fait, je voudrais réaliser une petite classe de sérialisation qui propose 2 méthodes : inserer(ostream&) et extraire(istream&).

Dans l'ésprit des interfaces java je me suis dis, je vais rendre insere et extraire virtuelle pure pour que le fait d'hériter de ma classe de Serialisation rendre obligatoire le fait de redefinir ces 2 méthodes.

Mon probleme est que je voudrais que lorsque on appel inserer ou extraire a partir d'une classe fille quelconque du code de ma classe de base Serialisation soit éxécuté automatiquement, un peut comme on peut appeler un constructeur parent a partir d'un constructeur fils...

Pourriez-vous m'indiquer une façon de faire ?

Je suis pas sûr d'avoir compris ta question, en gros tu veux appeler la méthode de la classe de base depuis la méthode redéfinie dans la classe dérivée ? Si c'est ça que tu souhaites faire en gros le principe c'est :

Code:

---

1 2 3

//dans le code de la méthode redéfinie "MaMethode" là ou t'en as besoin : ClasseMere::MaMethode()

---

Sinon une méthode un peu plus élégante :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

class Base {   public: void MethodePourLesClients() { //Code commun ici; MethodSpecific(); }   protected: virtual void MethodeSpecific() =0; };

---

Et tu redéfinis seulement MethodSpecific, ce qui assure que le code commun sera exécuté à chaque fois qu'un client appelera la méthode, et que tu doives réécrire les parties spécifiques dans chaque classe fille sans te soucier d'appeler le code commun depuis celle-ci.

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

class Serialization { public :   void inserer(ostream& os) { ... priv_inserer(os); }   private :   virtual void priv_inserer(ostream& os) = 0; };

---

Merci pour votre aide, je n'avais pas envisager cette solution mais je préfererais éviter de devoir manipuler dans les classes filles d'autres méthodes que celles que je redéfinie ; à savoir inserer et extraire.

Ça complique un peu l'histoire n'est ce pas ?

Pas du tout. Ton code est plus souple.
Tu as une interface qui demeure la même. Tu appelleras les mêmes fonctions de l'extérieur.
Cependant, intérieurement ça marche différemment de ce que tu avais prévu.
Sétipabeau ? :)

Citation:

---

Envoyé par Alp

Pas du tout. Ton code est plus souple.
Tu as une interface qui demeure la même. Tu appelleras les mêmes fonctions de l'extérieur.
Cependant, intérieurement ça marche différemment de ce que tu avais prévu.
Sétipabeau ? :)

---

Ça serait beau si j'avais une idée de comment faire ça oui ... ^^

Ben c'est le code qu'on t'a montré.

Tu as juste à appeler inserer/extraire sur une référence ou un pointeur vers une insance de classe héritant de Serializable.

Bonjour tout d'abbord merci pour votre aide, mais je pense que je me suis mal exprimé.
Au lieu d'extraire et insere je vais reprendre.

Voici ma classe suivi de ce que je voudrais arriver a faire :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

class MPacker{ private: ifstream istrm; ofstream ostrm;   public: virtual ~MPacker();   void initPacker(char *);   bool store(char* s); //insert value const char* retrieve(); //extract value   virtual void pack()=0; virtual void unpack()=0;   };

---

/***
* Utilisation:
* Heriter de cette classe.
* Redéfinir 'pack' et 'unpack' (serialiser et deserialiser).
* Utiliser 'store' pour inserer des valeurs avec pack.
* Utiliser 'retrieve' pour extraire des valeurs avec unpack.
* Appeler 'initPacker' avant tout appel a 'pack' ou 'unpack'.
***/

Le but étant pour l'instant de simplement gérer un petit fichier ou l'utilisateur de la classe s'engage a balancer des valeurs via store qu'il récuperera avec retrieve.

Un petit exemple tout bete :

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 28 29 30 31 32 33 34 35 36 37

class testcase : public Mpacker::MPacker{   public: MString nom,prenom,divers; testcase(){ nom="Dubois"; prenom="Robert"; divers="1234"; }; ~testcase(){};   void pack(){ store(nom.toString()); store(prenom.toString()); store(divers.toString()); }   void unpack(){ nom = retrieve(); prenom. = retrieve(); divers = retrieve(); } };     //et enfin pour tester tout ca: testcase *tc = new testcase(); tc->initPacker("./testcase.dat"); //tc->pack(); tc->unpack();   cout<<"nom="<<tc->nom<<endl; cout<<"prenom="<<tc->prenom<<endl; cout<<"divers="<<tc->divers<<endl;   //ok ca marche!

---

Ce que je voudrais faire :
Je voudrais que l'utilisateur n'ai pas a ce soucier de initPacker par exemple.
Je voudrais qu'il ai simplement a redéfinir pack et unpack...
Mais, toujours par exemple, qu'avant sont code au sein de pack le code d'initPacker soit executé.

Je crois qu'une solution serait les macros, genre on redefini "pack(){" en "pack(){initPacker(\"blablabla\")" mais c'est moche et dangereux...

Voila je pense avoir été plus clair que je ne l'ai été.

Connaissez vous donc un moyen d'arriver a faire cette "pre-execution" de code au sein de pack et unpack ?

La seule qui peut insérer un bout de code qui ne soit ni visible par l'appelant ni par la dérivée, c'est la classe de base. Or c'est exactement ce qu'on t'a montré... Ca a même un nom, ça s'appelle le design pattern template method. Qu'est-ce qui te gêne avec cette solution ?

Citation:

---

Envoyé par Laurent Gomila

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

class Serialization { public :   void inserer(ostream& os) { ... priv_inserer(os); }   private :   virtual void priv_inserer(ostream& os) = 0; };

---

---

Si il faut redefinir priv_insérer pour utiliser inserer ça n'est pas ce que je veux faire.

Salut,

C'est juste une histoire de nommage...
Et là comme ç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 28

class MPacker { public: virtual ~MPacker();   bool store(char* s) { initPacker( s ); // sans doute des trucs ? pack(); // sans doute d'autres trucs ? return ?! } const char* retrieve() { // des trucs unpack(); // d'autres trucs return ?! }   protected: virtual void pack()=0; virtual void unpack()=0;   private: void initPacker(char *); };

---

MAT.

Ok merci pour vos réponses effectivement c'est plus clair... :oops:
Vais voir ce que je peux faire comme ça ;-)