Surcharge et Polymorphisme

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

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:

---

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

---

polymorphisme dynamique :

Code:

---

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:

---

~A();

---

quand tu fais :

Code:

---

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:

---

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:

---

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

---

tu ne peux pas instancier A :

Code:

---

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:

---

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

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:

---

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:

---

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() ...

---

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?

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:

---

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:

---

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...

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?

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.