1. Polymorphisme
Dynamique et Statique
Réaliser Par :
HERAGUEMI KAMEL EDDINE
1

2. Définition du polymorphisme
Le nom de polymorphisme vient du grec et signifie qui peut prendre
plusieurs formes. Cette caractéristique est un des concepts essentiels de la
programmation orientée objet. Alors que l'héritage concerne les classes
(et leur hiérarchie), le polymorphisme est relatif aux méthodes des objets.
On distingue généralement trois types de polymorphisme :
• Le polymorphisme ad hoc (également surcharge ou en anglais
overloading) ,
• Le polymorphisme paramétrique (également généricité ou en anglais
template) ,
• Le polymorphisme d'héritage (également redéfinition, spécialisation ou
en anglais overriding) .
2

3. Le polymorphisme ad hoc
• Permet d'avoir des fonctions de même nom, avec des fonctionnalités
similaires, dans des classes sans aucun rapport entre elles . Par exemple, la
classe complexe, la classe image et la classe lien peuvent avoir chacune
une fonction "afficher". Cela permettra de ne pas avoir à se soucier du
type de l'objet que l'on a si on souhaite l'afficher à l'écran.
3

4. Le polymorphisme ad hoc
• Permet ainsi des conversions implicites, ou coercions, présente
dans pas mal de langages, au moins pour des types de base, certains
permettant même à l’utilisateur de définir des conversions qui seront
appliquées implicitement. Il est donc possible par exemple de
surcharger l'opérateur (+) et de lui faire réaliser des actions différentes
selon qu'il s'agit d'une opération entre deux Réels ou entre deux Entiers
{ ….
int x=2 ,y=5;
float x1 =2.122 ;
Test t1 = new Test () ;
t1.Add(x,y);
t1.Add(x1,y);
……
}
4

5. Le polymorphisme paramétrique
 Appelé généricité, représente la possibilité de définir plusieurs
fonctions de même nom mais possédant des paramètres différents (en
nombre et/ou en type).
 Rend ainsi possible le choix automatique de la bonne méthode à
adopter en fonction du type de donnée passée en paramètre.
EXEMPLE :
On peut par exemple définir plusieurs méthodes homonymes addition()
effectuant une somme de valeurs.
• La méthode int addition(int a, int b) pourra retourner la somme de
deux entiers
• La méthode float addition(float a, float b) pourra retourner la somme
de deux flottants
• La méthode string addition(char a, char b) pourra la concaténation de
deux caractères .
Alors , C'est la signature d'une méthode qui détermine laquelle sera
appelée.
5

6. Le polymorphisme d'héritage
• La possibilité de redéfinir une méthode dans des classes héritant d'une
classe de base s'appelle la spécialisation. Il est alors possible d'appeler la
méthode d'un objet sans se soucier de son type intrinsèque : il s'agit du
polymorphisme d'héritage. Ceci permet de faire abstraction des détails des
classes spécialisées d'une famille d'objet, en les masquant par une
interface commune (qui est la classe de base).
6

7. Polymorphisme Dynamique et statique
Polymorphisme statique - présentés par les fonctions surchargées au
moment de compilation .
Polymorphisme dynamique - présentés en utilisant une liaison dynamique
crier en runtime.
7

8. Polymorphisme statique
• polymorphisme statique fait référence à une entité existante sous
différentes formes physiques simultanément.
• polymorphisme statique implique la liaison des fonctions basées sur
le nombre, le type et la séquence des arguments.
• Les différents types de paramètres sont spécifiés dans la déclaration
de fonction, et donc la fonction peut être lié à des appels à la
compilation.
• Cette forme d'association est appelé une liaison anticipée.
• Le terme liaison anticipée découle du fait que lorsque le programme
est exécuté, les appels sont déjà liés à des fonctions appropriées.
8

9. Polymorphisme statique
Exemple 1:
Void affi( int val ) {printf (‘ %d’,val);};
Void affi(float val){printf (‘%f’,val);};
//…..
Class test{
int i ;
void affiche (){printf (‘%d’,i)}
}
//……
Void affi(test& val ) {val.affiche ()};
//……..
Void main (){
int Mon_indice = 20; affi(mon_indice);
test t1 ; affi (t1);
}
9

10. Polymorphisme dynamique
• polymorphisme dynamique réfère à une entité change de forme selon
les circonstances.
• Une fonction est dite présenter polymorphisme dynamique quand il
existe dans plus d'une forme, et demande à ses diverses formes sont
résolus de façon dynamique lorsque le programme est exécuté.
• Le terme liaison dynamique se réfère à la résolution des fonctions au
moment de l'exécution au lieu de la compilation.
• Cette caractéristique augmente la flexibilité du programme en
permettant la méthode appropriée à être invoqués, selon le contexte.
• La combinaison de l'héritage, de la virtualité et la possibilité de
surcharger des méthodes permettent ce polymorphisme dynamique.
10

11. Polymorphisme dynamique
figure *f;
// ...
switch(...) {
case ... :
f = new rectangle; break;
case ... :
f = new carre; break;
case ... :
f = new hexagone; break;
}
f->afficher();
// On voudrait appeler la bonne version
// de afficher selon la valeur de f
// Actuellement : appel de
// figure::afficher() !!!
// .... transformer afficher
// en fonction virtuelle
11

12. Méthode virtuelle (1)
• La mise en place du polymorphisme dynamique se réalise par
l'intermédiaire des méthodes virtuelles.
• Une méthode est marquée virtuelle par l'ajout du mot clé virtual au
niveau de la déclaration uniquement.
class figure { ...
public:
virtual void afficher(void) const;
};
class rectangle : public figure { ...
public:
virtual void afficher(void) const;
};
rectangle r;
figure *ptf;
ptf->afficher() ; // figure::afficher()
figure& rf=r;
rf.afficher(); //rectangle::afficher()
12

13. Méthode virtuelle (2)
• La détermination de la méthode à appeler est effectuée dynamiquement
selon le type effectif de l'objet pointé ou référé (on parle de liaison
dynamique).
• Une méthode virtuelle reste virtuelle dans tout l'arbre de
dérivation, même si elle n'est pas redéclarée virtuelle dans les classes
dérivées.
• Pour redéfinir une méthode virtuelle héritée, nécessité d'adéquation
parfaite : signature et type de retour (sinon, la fonction virtuelle est
masquée).
• Les fonctions membres statiques ne peuvent pas être virtuelles.
13

14. Exemple
class A {
public :
virtual void f () { cout << "A"; } ;
};
class B : public A {
public:
// foo reste virtuelle
void f () { cout << "B"; } ;
};
class C : public B {
public:
// foo reste virtuelle
void f() {cout << "C"; };
};
int main() {
A * a = new C;
B * b = new C;
a->f(); // foo virtuelle --> C::f()
14
b->f(); // foo virtuelle --> C::f()

15. Merci pour Votre Attention
15

16. 16