Discussion :

[cibatro]

Bonjour,

Je viens régulièrement sur le site et le forum quand j'ai des questions de code et aujourd'hui j'ai une question à laquelle je n'ai pas encore trouvé de réponse.

Supposons que plusieurs classes héritent d'une même classe mère. Cette classe mère a (entre autres) une méthode virtuelle. Est ce qu'il a un moyen de savoir si cette méthode a été redéfinie dans les classes enfants ou pas?

Merci d'avance!

[Davidbrcz]

Je ne peux pas le garantir à 100% (il y'a peut être quelques hacks que je ne connais pas) mais je dirais que non.

La vraie question est : Pourquoi as tu besoin de savoir cela ?

[koala01]

Salut, et bienvenue sur le forum

De prime abord, je dirais que non, et que, de toutes manières, tu n'a a priori aucun besoin de le savoir

Ceci dit, je me demande si ta question ne porte pas plutôt sur comment être sûr qu'une fonction virtuelle sera redéfinie dans les classes dérivées...

Dans ce cas, la clé réside dans l'utilisation de fonction(s) virtuelle(s) pure(s), éventuellement associée(s) avec l'idiome NVI (Non Virtual Interface).

NB: une classe dans laquelle il existe une fonction virtuelle pure est, par définition même ce que l'on appelle une classe abstraite.

Il est donc impossible d'instancier une classe dans laquelle il existe une fonction virtuelle pure (par contre, il est possible de faire passer l'instance d'une classe dérivée pour une instance de la classe parent), tout comme il est impossible d'instancier une classe dérivée dans laquelle toutes les fonctions virtuelles pures n'auront pas été redéfinies

[jabbounet]

je confirme pour le virtuelle pure, qui va te forcer d'implémenter la méthode dans toutes les classes filles


cependant si ce n'est pas ton besoin, tu peux le gérer de façon manuelle avec un simple booléen/compteur privé dans la classe mère que tu met a jour dans la méthode virtuelle de ta classe mère et encore c'est un peu bancal, tu peux aussi jeter une exception qui ne sera pas jeté dans les filles, mais la méthode virtuelle pure est une bien meilleure approche.....
j'ai du mal a voir le besoin....

[koala01]

jcependant si ce n'est pas ton besoin, tu peux le gérer de façon manuelle avec un simple booléen privé dans la classe mère que tu met a jour dans la méthode virtuelle de ta classe mère et encore c'est un peu bancal.....

C'est même tout à fait bancal, dans le sens où ce booléen ne serait de toute façon pas mis à jour avant l'invocation de la fonction virtuelle (du moins dans la version que tu présente)...

Ainsi un code proche de

Code :

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

1
2
3
4
5
 
Base* b = new Derivee;
std::cout<<b->isReimplemented()<<std::endl;
b->foo();
std::cout<<b->isReimplemented()<<std::endl;

donnerait pour le premier appel de isReimplemented (qui ne ferait que vérifier le boolée) un résultat faux alors que le deuxième donnerait un résultat vrai

La solution serait alors de mettre ce booléen à jour dans le constructeur, mais... nous serons alors confronté au problème majeur de l'erreur humaine et de la loi de Finagle: tu trouveras toujours un "imbécile" pour oublier de mettre le booleen à jour lorsqu'il redéfinit la fonction virtuelle ou un autre pour mettre le booléen à jour alors... qu'il n'a pas redéfini la fonction virtuelle...

Bref, le mot bancal est faible

[cibatro]

Merci pour vos réponses.

En fait, j'utilise des bibliothéques de physique qui ont été développées par d'autres personnes.
Par défaut dans la classe mère cette méthode va faire certains calculs. Ces calculs par défaut ne m'intéressent pas. Cette méthode ne m'intéresse que pour les classes enfants qui la redéfinissent. Le problème c'est que cette méthode est appelée plusieurs milliards de fois et je ne veux pas faire les calculs par défauts de la classe mère pour les classes enfants qui ne redéfinissent pas cette méthode (pour essayer de gagner un peu de temps de calcul). Et j'aimerais éviter de retoucher aux bibliothèques de bases.

[koala01]

Merci pour vos réponses.

En fait, j'utilise des bibliothéques de physique qui ont été développées par d'autres personnes.
Par défaut dans la classe mère cette méthode va faire certains calculs. Ces calculs par défaut ne m'intéressent pas. Cette méthode ne m'intéresse que pour les classes enfants qui la redéfinissent. Le problème c'est que cette méthode est appelée plusieurs milliards de fois et je ne veux pas faire les calculs par défauts de la classe mère pour les classes enfants qui ne redéfinissent pas cette méthode (pour essayer de gagner un peu de temps de calcul). Et j'aimerais éviter de retoucher aux bibliothèques de bases.

Tu n'as donc absolument pas besoin de savoir si la fonction est redéfinie dans tes propres classes, tout ce dont tu as besoin, c'est d'utiliser le polymorphisme qui est induit par le fait que les fonctions sont virtuelles

Le polymorphisme assure que, quel que soit le type D qui hérite d'une classe B, si tu fais appel à une méthode définie dans B (et redéfinie dans D), ce sera le comportement propre au D qui sera appelé... Et c'est exactement ce que tu souhaite

[jabbounet]

Merci pour vos réponses.

je ne veux pas faire les calculs par défauts de la classe mère pour les classes enfants qui ne redéfinissent pas cette méthode (pour essayer de gagner un peu de temps de calcul). Et j'aimerais éviter de retoucher aux bibliothèques de bases.

tu fait une méthode vide dans tes classe filles (en espérant ne pas en oublier.)

[cibatro]

Oui mais je n'ai pas développé les classes enfants. Les développeurs n'ont pas mis de méthode vide car dans la plupart des cas on a besoin des calculs réalisés dans la méthode de la classe mère.

Je pourrais modifier les bibliohèques pour mon application mais comme ces bibliothèques sont susceptibles d'évoluer je voulais essayer de faire quelque chose d'un peu propre.

[jabbounet]

Oui mais je n'ai pas développé les classes enfants. Les développeurs n'ont pas mis de méthode vide car dans la plupart des cas on a besoin des calculs réalisés dans la méthode de la classe mère.

Je pourrais modifier les bibliohèques pour mon application mais comme ces bibliothèques sont susceptibles d'évoluer je voulais essayer de faire quelque chose d'un peu propre.

dans ton appli tu faits des enfants des classe filles dont tu te sert et de celle que tu souhaite ne pas appeler l'algo de la grand-maman et tu les utilise...

pas besoin de changer la lib pour ça (si c'est une contrainte forte de ne pas la changer). après cela te fais gérer des petits enfants et ça complique un peu mais tu ne modifie pas ta lib.

[Davidbrcz]

Suffit de créer une classe tampon qui va annuler le calcul que tu veux et ne manipuler plus que ca.
Exemple

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 Base // classe pas faite par toi
{
public:
virtual void foo() {/*plein de truc compliqué*/}
};
 
class Tampon : public Base // classe faite par toi
{
public:
virtual void foo() {/*rien*/}
};
 
//ensuite tes classes qui héritent de Tampon
class D1 : public Tampon
{
public:
virtual void foo() {/*calcul 1*/}
};
 
class D2 : public Tampon
{
public:
virtual void foo() {/*calcul 2*/}
};
 
//après, suffit de manipuler des Tampon* pour avoir le polymorphisme avec ses enfants et plus de problème de calcul inutile.

[cibatro]

Ah ben, oui. Tu as raison jabbounet c'est le plus simple!

Merci à tous!