Polymorphisme : appel automatique de la fonction du parent

Hello,

J'ai une fonction que je définis polymorphiquement dans une classe de base, et qui est redéfinie plusieurs fois en descendant dans la hiérarchie. Ce qui commun est codé le plus haut possible dans la hiérarchie.

On a donc :

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

class A { virtual void process() { ...; } };   class B : public A { virtual void process() { A::process(); ...; } };   class C : public B { virtual void process() { B::process(); ...; } };

---

Y a-t-il moyen de faire en sorte que chaque classe enfant appelle automatiquement la fonction équivalente de son parent ?

Merci.

Si je comprend bien tu voudrai ne pas avoir à écrire A::process(); dans B::process(). Parce que sa coute pas très cher de l'écrire quand même :mouarf:.

Ben si un des process() de A est défini comme virtuel pur, que des dizaines de classes héritent de A, et que tu décides de finalement faire une implémentation pour A, faut revenir dans toutes les classes enfant pour explicitement appeler A::process().

C'est faisable, mais ça vaut le coup de se poser la question, non ? :-)

Fais attention dans ton exemple, tu n'as pas d'héritage, et tu as deux classes B ! :lol:

Citation:

---

Envoyé par oodini

C'est faisable, mais ça vaut le coup de se poser la question, non ? :-)

---

Oui, ça vaut le coup de se poser la question. La réponse est toute bête, il suffit pas implémenter la fonction virtuelle de la classe fille, et elle prendra alors l'implémentation de la classe parent.

Après pense au pattern template method, qui permettra en plus d'appliquer du NVI, et d'être un peu plus souple. :ccool:

Citation:

---

Envoyé par poukill

Fais attention dans ton exemple, tu n'as pas d'héritage, et tu as deux classes B ! :lol:

---

Merci. c'est corrigé !

Citation:

---

Envoyé par poukill

Oui, ça vaut le coup de se poser la question. La réponse est toute bête, il suffit pas implémenter la fonction virtuelle de la classe fille, et elle prendra alors l'implémentation de la classe parent.

---

Non, car l'implémentation dans la classe fille rajoute des instructions par rapport à l'implémentation de la classe parent. Elle spécialise.
Et la fonction parente factorise des instructions communes aux classes filles.

Citation:

---

Envoyé par poukill

Après pense au pattern template method, qui permettra en plus d'appliquer du NVI, et d'être un peu plus souple. :ccool:

---

Intéressant, mais ça ne répond pas vraiment à mon problème.
Par ailleurs, j'ai implémenté cette technique hier sans savoir que c'était un pattern, mais seule la fonction de la classe parent était appelée... Mais bon, c'est l'objet d'un autre thread. :-)

Si, ça répond au problème, d'après ce que j'ai compris

Code:

---

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

class A { public: void Apply() { ApplyImpl(); }   private: virtual ApplyImpl(); // avec éventuellement une implémentation par défaut. };

---

Et paf, du coup, tes classes filles n'ont qu'une seule fonction à implémenter.
Tu peux même rajouter un traitement dans Apply() qui est optionnel

Code:

---

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

class A { public: void Apply() { ApplyImpl(); ApplyOptional(); }   private: virtual ApplyImpl(); // avec éventuellement une implémentation par défaut. virtual ApplyOptional() {} };

---

Du coup t'as défini une structure pour un algo, c'est le template method ! :D

Du coup, si on a une hiérarchie à 3 niveaux, cela donne :

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

class A { public: void Apply() { ...; ApplyImpl(); }   private: virtual ApplyImpl(); };   class B : public A { public: void ApplyImpl() { ...; ApplyImpl2(); }   private: virtual ApplyImpl2(); };   class C : public B { public: void ApplyImpl2() { ...; } } ;

---

C'est bien ça ?
Si oui, cela implique donc un ajout de fonction virtuelle par génération, sauf pour les feuilles. Moins de boulot de saisie, mais quelques inconvénients à l'exécutions, non ?

Ce n'est pas une critique; c'est seulement pour que je comprenne.

Note: j'ai une hiérarchie avec au maximum 5 niveaux, et de nombreuses feuilles.

Seuls les constructeurs et destructeurs sont appelés 'automatiquement' le long de l'arbre d'héritage.
Il est vrai qu'avec un une profondeur supérieure à 2, la méthode proposée devient vite laborieuse. Mais présupposer que tu auras besoin d'appeler la fonction de chaque étape est étrange. Peut être as-tu trop de responsabilité dans ta méthode et qu'il faut associer une hiérarchie d'objet 'préparateur' qui pourrait 'remonter' ta hiérarchie première.