Discussion :

[nuKs]

Bonjour.
J'aimerais savoir s'il existe des cas où une méthode virtuelle est à rejetée. Bien que certaines méthodes de mon programme ne seront en principe jamais redéfinies, j'ai pris l'habitude de déclarer toutes les méthodes comme virtuelles. Au cas où.

Est-ce une mauvaise idée ?
Existe-t-il des cas où les méthodes virtuelles empêchent le bon fonctionnement de la classe ?
Y a-t-il une perte de performance ?
Bref, est-ce que cela affecte l'exécutable d'une quelconque manière ?

Merci d'avance !

Edit: Je viens par pur hasard de tomber sur un cas où les méthodes virtuelles ne fonctionnent pas (bien que ce soit un peu hors sujet):
Lors d'un appel du constructeur de la classe mère, s'il y a appel à une méthode virtuelle dans celui ci, la méthode de la classe mère sera appelée, et non celle de la classe fille. Ceci est du au fait que la classe fille n'est pas encore construite à ce moment.

[fictou]

Bonjour nuks

Une méthode devrait être déclarer virtuelle lorsque les deux conditions suivantes sont remplies:

1) Elle est redéfinie par une classe dérivée.
2) Elle est appelée par une méthode de la classe de base.

Si l'une des conditions n'est pas remplie, il est inutile de déclarer la méthode virtuelle. (tout simplement, si la méthode n'est pas redéfinie par une classe dérivée, il est clair que la méthode n'a pas besoin d'être virtuelle)

Si 1) est remplie mais pas 2), alors une substitution simple suffira pour la classe dérivée.

Mais pourquoi tout ce tralalala!

Imaginons les classes suivantes:

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
class Animal {
    char nom[45], espece[45];
 
protected:
    Animal(char *nom, char *espece);
    ~Animal();
 
public:
    virtual void naissance();
    void elevage(); //la méthode qui appellera naissance pour la condition 2)
};
 
 
class Chien {
 
public:
    Chien(char *nom);
};
 
class Poule {
 
public:
    Poule(char *nom);
    void naissance();
};

Et le code suivant:

Code :

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

1
2
3
4
5
6
7
 
main() {
    Chien chien("Toutou");
    Poule poule("Chicken Little");
    chien.elevage(); //naissance() est appelé depuis Animal
    poule.elevage(); //naissance() est appelé depuis Poule
}

Ainsi lorsque la méthode elevage est appelée en passant par l'instance de la classe Poule, le programme appellera la méthode elevage de la classe de base qui appellera la méthode naissance. Mais comme la méthode naissance est virtuelle, ce ne sera pas celle de la classe de base qui sera utilisé mais celle de Poule.

Une méthode virtuelle permet en fait au programme d'effectuer un chaînage de méthode dynamique.

Si tu enlève le virtual, tu remarqueras que ce chaînage dynamique ne s'effectuera plus et que la ligne suivante:

Code :

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

poule.elevage();

n'appellera plus la méthode naissance redéfinie par Poule mais bien celle de la classe de base, soit Animal.

Bel exemple de polymorphisme...

[fictou]

....j'ai pris l'habitude de déclarer toutes les méthodes comme virtuelles. Au cas où.

Est-ce une mauvaise idée ?

1. OUI!!

Existe-t-il des cas où les méthodes virtuelles empêchent le bon fonctionnement de la classe ?

2. Si tu comprend bien l'exemple, tu peux voir les ennuis que cela peut te générer...(mauvaise méthode appelé, etc..)

Y a-t-il une perte de performance ?

3. 2) te donnent une idée...

Bref, est-ce que cela affecte l'exécutable d'une quelconque manière ?

4. 1) 2) et 3)

[nuKs]

Tout d'abord, merci de ta réponse ;-)
Je me permet d'ajouter (en espérant ne pas me tromper) le cas où l'on utilise un pointeur de la classe mère qui pointe vers la classe fille. Si la méthode appelée n'est pas virtuelle, la méthode appelée sera celle de la classe mère et non de la classe fille.

Donc si j'ai bien compris, le fait de déclarer une méthode virtuelle (qui ne devrait pas l'être) pourrait causer un sérieux ennui si l'on veut appeler sa "version" de la classe mère et qu'on se trouve dans une classe fille.

C'est un cas extrêmement rare, et j'ai pris l'habitude, dans cette situation, de toujours déclarer explicitement la classe mère quand je voulais utiliser une de ses méthodes Ca expliquerait pourquoi ça ne m'a jamais poser de problème. Toutefois, la situation risque donc de dégénérer si le code de la classe fille ne vient pas de moi.

Le problème serait surtout de savoir qu'elle méthode de la classe mère ne sera donc pas redéfinie dans la classe fille et sera utiliser par une méthode de cette classe fille. Ca risque de me demander un petit temps de réflexion pour chaque méthodes :/

[3DArchi]

Bonjour,
Déclarer toutes ses méthodes comme virtuelles n'est pas à prescrire. La raison fondamentale est que cela traduit un gros défaut de conception. C'est que tu ne sais pas définir la responsabilité de ta classe.
Accessoirement, tu auras une chute drastique des performances.

[zais_ethael]

Écoute, c'est bien simple. Les méthodes virtuelles servent à faire du polymorphisme objet en C++. Si tu ne fais pas de polymorphisme objet les utiliser ne t'apportera qu'une perte de performance inutile.
Au fait, même si je ne devrais pas avoir à l'expliquer, contrairement à d'autres langages comme le C#, faire du polymorphisme objet en C++ ne revient pas simplement à ajouter un mot clé virtual à coté des méthodes.
Néanmoins pour les classes n'étant utilisées que de manière polymorphe déclarer toutes les méthodes virtuelles est parfaitement valide.

[3DArchi]

Néanmoins pour les classes n'étant utilisées que de manière polymorphe déclarer toutes les méthodes virtuelles est parfaitement valide.

C'est valide mais j'ai jamais vu le cas. Pour moi, si tu tombes dans ce cas, ça doit faire tilt au niveau de la conception.

[nuKs]

Merci à tous pour vos réponses. Tout est ok.

[zais_ethael]

C'est valide mais j'ai jamais vu le cas. Pour moi, si tu tombes dans ce cas, ça doit faire tilt au niveau de la conception.

Ben, et pour les interfaces alors?

@Loic: Tu ne serais pas en train de parler du design pattern template method? Si c'est le cas, faut quand même pas généraliser. Tout n'est pas applicable à ce pattern et il est facile de transformer un tel design vers un système utilisant des interfaces ou encore de la méta programmation.