Discussion :

[Hell]

Bonjour
J'ai lu plusieurs tutoriels de c++ et j'ai un peu de mal à comprendre certaines choses en c++

Quelle est la différence entre le polymorphisme et la surcharge?
A quoi sert le mot virtual ? Car en fonction du tutoriel, il est ou n'est pas utilisé

Merci d'avance pour vos explications
Bonne journée

[FVIRTMAN]

la surcharge et le polymorphisme sont 2 choses différentes !
Apres, il y a plusieurs choses différentes

surcharge :

operator+ operator* etc, sont des surcharges d'opérateurs

polymorphisme
statique :

Code :

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

1
2
void fonction(int a);
void fonction(double a);   // 2 formes différentes --> polymorphe

polymorphisme dynamique :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
//définition :
class A
{}
 
class B:public A {...}
class C:public A {...}
 
// usage
A* test; // pointeur vers A
test = new B();
test->plouf(); // .....
delete test;
test = new C();

en gros tu manipules une classe fille grace a un pointeur sur la mere...

pour virtual, que tu mettras dans la classe A, ça sert a utiliser les membres de la fille. Exemple connu sur les destructeurs :

si tu définis dans A :

Code :

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

~A();

quand tu fais :

Code :

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

1
2
3
A* test; // pointeur vers A
test = new B();
delete test;

--> fuite de mémoire, car uniquement le destructeur de A est appelé, si tu as contruit des trucs dans B, c'est autant de mémoire perdue

maintenant :
si tu définis dans A :

Code :

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

virtual ~A();

ça appellera aussi le destructeur de B, tout propre

sinon, tu as ce qu'on appelle le virtual pure :

si tu définis dans A :

Code :

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

virtual void fonc()=0; // =0 marque du virtual pure

tu ne peux pas instancier A :

Code :

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

1
2
3
A test;  // interdit.
A* test; // permis
test = new A(); // interdit.

Par contre, cette méthode dit que tu es OBLIGE de définir
void fonc() dans les filles : donc tu es obligé de mettre, dans B :

Code :

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

void fonc();

Le virtuel pure impose aux classes filles d'avoir une fonction précise, et interdit la classe mere d'etre instanciée seule.

Apres, je pourrais t'en écrire des tartines : précise les points sur lesquels tu accroches

[Gandalf]

La surcharge, c'est la possibilité de differencier deux fonctions ou deux methodes portant le meme nom par leur listes d'arguments. L'exemple frequent, meme s'il n'est pas le meilleur :

Code :

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

1
2
3
 
int max(int a, int b);
double max(double a, double b);

Il y a là deux fonctions max, l'un operant sur des entiers l'autre sur des double.

C'est le compilateur qui decide quelle fonction doit etre appellée.

Le polymorphisme, lui est lié à l'heritage c'est la possibilité pour un objet de redéfinir des methodes de son objet pere.
seules les methodes "virtuelles" du pere peuvent etre redefinies
ici le compilateur ne decide pas quelle methode est appellée c'est ce que l'on appelle l'edition des liens tardive:

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
 
class A
{
   public:
   virtual fct();
   virtual ~A(); //Si une classe est destinée a etre herité mieux vaux que son destructeur soit virtuel
};
 
class B : public A
{
   public :
   virtual fct(); //fct sera redefini
};
 
...
A *aPtr = new B; // Pointeur sur A pointant en fait sur un B.
aPtr->fct(); //appelle effectivment B::fct() et non A::fct()
...

[Hell]

d'accord j'ai tout compris, maintenant c'est clair pour moi
je faisais pas vraiment la différence entre les deux, pour moi c'était la même chose

autrement, est il possible de mettre un mot clé qui empêcherait de redéfinir une fonction de la classe mère dans la classe fille?

[Gandalf]

l'equivalent du "final" de java n'existe pas.

En pratique ne pas mettre de "virtual" rend la redefinition caduque. Elle reste possible mais ne sera prise en compte que sur un appel direct à l'objet:

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
 
 
class A
{
   public:
   void fct1();
   virtual fct2();
   virtual ~A();
};
 
class B : public A
{
   public:
   void fct1();
   virtual fct2();
};

fct1 est redefinie dans B bien que non virtuelle dans A
fct2 est redefinie dans B et virtuelle dans A

Code :

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

1
2
3
4
5
6
7
8
9
10
 
B b;
 
b.fct1(); //appelle B::fct1
b.fct2(); //appelle B::fct2
 
A* aPtr = new B
 
aPtr->fct1(); //!!! appelle A::fct1
aPtr->fct2(); // appelle B:fct2

Par contre une fois qu'une fonction a été definie virtuelle il n'est pas possible de revenir en arriere, une classe C heritant de B peut redefinir fct2...

[Hell]

ah ok, merci
par contre y'a une autre question que je me pose

le mot virtual est à utliser uniquement dans le prototype de la fonction ou on doit aussi le marquer lorsqu'on écrit entierement la fonction?

[Luc Hermitte]

Un petit point de vocabulaire.

Une des terminologies donne:
"polymorphisme" = "polymorphisme ad'hoc" (PA) + "polymorphisme universel" (PU)

PA = les "convertions implicites" (int vers double p.ex) + la "surcharge"

PU = "polymorhisme paramétrique" (qui se rapproche en C++ de la généricité façon templates) + "polymorphisme d'héritage" (aka "P. d'inclusion", et peut-être même aka "P. de sous-typage", à vérifier).

Ce dernier polymorphisme (d'héritage -- PdH) est celui que 99% des gens bossant avec des objets appellent simplement polymorphisme -- bien qu'historiquement il ne serait pas le premier polymorphisme à avoir été utilisé en informatique. Mais bref.
En C++, le PdH se met en oeuvre à l'aide des fonctions virtuelles.
(EDIT: à ce sujet, IIRC, c'est "link" qui se traduit par "édition de liens", pas "binding" ; le terme officiel C++ doit probablement être "liaison dynamique", et j'aime beaucoup "liaison tardive")


Concernant ta dernière question, virtual ne se spécifie que dans le prototype. Côté corps, au mieux tu le mets entre commentaires.