Polymorphisme [208-224]

Polymorphisme : sommaire

Polymorphisme 1

Polymorphisme

Le polymorphisme désigne la faculté de prendre plusieurs formes.

Deux expressions du polymorphisme :

Polymorphisme statique : le choix de la forme appropriée est déterminé au moment de la compilation à partir de la déclaration de l'objet polymorphe.
--> mécanisme de surcharge.
Polymorphisme ``dynamique'' : le choix de la forme appropriée se fonde sur le type de l'objet au moment de l'exécution.
--> mécanisme de liason ``dynamique''.

Polymorphisme 2

Polymorphisme statique

Nommage : les fonctions membres peuvent avoir le même nom pour des traitements différents dans des classes différentes.

compte c ; rectangle p ;

c.afficher() ; p.afficher() ;

Surcharge des fonctions et des opérateurs :

class figure {

public :

void afficher(const couleur fond) const ;

void afficher(const string message) const ;

void afficher(void) const ;

figure& operator = (const figure&) ;

// ...

} ;

Polymorphisme 3

Polymorphisme dynamique (1)

Lors de la conception d'un système, il est fréquent que les programmeurs connaissent :
- l'interface nécessaire pour une classe, sans connaître à priori l'implémentation la plus adaptée ;
- les algorithmes nécessaires, sans toutefois connaître comment des opérations particulières, propres aux données manipulées, doivent être implémentées.
--> reculer certaines décisions le plus longtemps possible.
--> la liaison dynamique est une solution possible en définissant des services dans des classes de base et en les implémentant dans les classes dérivées.

Polymorphisme 4

Polymorphisme dynamique (2)

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

Polymorphisme 5

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=&r;

ptf->afficher() ; // rectangle::afficher()

figure& rf=r;

rf.afficher(); //rectangle::afficher()

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

Polymorphisme 6

Méthode virtuelle (2)

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).
--> selon les compilateurs, erreur de compilation.
Les fonctions membres statiques ne peuvent pas être virtuelles.

Polymorphisme 7

Méthode virtuelle (3)

class A {

public :

virtual void foo() { cout << "A"; } ;

};

class B : public A {

public:

// foo reste virtuelle

void foo() { cout << "B"; } ;

};

class C : public B {

public:

// foo reste virtuelle

void foo() {cout << "C"; };

};

int main() {

A * a = new C;

B * b = new C;

a->foo(); // foo virtuelle --> C::foo()

b->foo(); // foo virtuelle -->C::foo()

Polymorphisme 8

Table de fonctions virtuelles (1)

Le mécanisme de polymorphisme dynamique est réalisé par les tables de fonctions virtuelles :

Toute classe ayant au moins une fonction virtuelle génère une ou plusieurs tables (vtables) : tableau logique de pointeurs sur fonctions membres.
Toute instance d'une classe ayant des fonctions membres virtuelles contient un ou plusieurs pointeurs (vptrs) pointant sur la table appropriée de l'objet.
--> Le constructeur initialise les valeurs de ces vptrs avec les bonnes valeurs des vtables.
--> Le choix de la fonction membre virtuelle adéquate est un accès à son adresse stockée dans la table de l'objet référencé ou pointé lors de l'exécution au moment de l'exécution de la méthode.

Polymorphisme 9

Table de fonctions virtuelles (2)

class rectangle : public figure{

protected:

int l,lg;

public:

rectangle(int x=0, int y=0): l(x),lg(y){}

virtual int perimetre(void) const ;

int aire(void) const ;

};

class carre : public rectangle {

public:

carre(int l=0) : rectangle(l,l) {}

int perimetre(void) const ;

int aire(void) const ;

};

int main() {

rectangle * r = new rectangle(20,30);

cout << r->perimetre() << endl;

carre * c = new carre(10);

r = c;

cout << r->perimetre() << endl;

cout << r->aire() << endl;

}

Polymorphisme 10

Tables de fonctions virtuelles (3)

rectangle * r;

r = new rectangle(20,30) ;
// mise en place du vptr adéquat -->

r->perimetre() ; // rectangle::perimetre

carre * c = new carre(10) ;
// mise en place du vptr adéquat
r = c;

r->perimetre() ; // carre::perimetre

r->aire(); // rectangle::aire résolu à la compilation
// ((carre *) r)->aire(); --> carre::aire

Polymorphisme 11

Destructeur virtuel

class Base { ...

};

class Deriv : public Base {

int *pt ; ...

public:

Deriv() { pt = new int[10]; }

~Deriv() { delete [] pt; }

// ...

};

Base *ptB = new Deriv;

delete ptB;// a priori appel de ~Base()

// --> espace mémoire non libéré

Si une classe dérivée a un destructeur, déclarer le destructeur de la classe de base comme étant virtual

class Base {

virtual ~Base(); //...

};

Polymorphisme 12

Méthode virtuelle et encapsulation

le droit d'accès peut être modifié tout au long de l'arbre d'héritage,

la protection dépend de la manière d'invoquer, et non de la méthode réellement invoquée :

class Base {...

public:

virtual void virtMet() {...}

};

class Deriv : public Base {...

protected:

virtual void virtMet() {...}

};

Deriv f;

f.virtMet(); // Erreur : Deriv::virtMet()

// est protégée

Base *ptB=&f;

ptB->virtMet();

// OK: Base::virtMet publique

// MAIS APPEL DE Deriv::virtMet() !!!

Polymorphisme 13

Fonction virtuelle pure

Si au sommet de la hiérarchie d'héritage la méthode virtuelle ne peut pas être définie, en faire une méthode virtuelle pure (i.e. la définir par'=0'.)
Ex. on veut déclarer une méthode virtuelle perimetre() au niveau de la classe figure :

class figure { ...

public:

virtual int perimetre() const =0;

...

};
Si une classe hérite d'une fonction virtuelle pure et ne la redéfinit pas, alors elle reste virtuelle pure dans la classe dérivée.

Polymorphisme 14

Classe abstraite

Une classe est dite abstraite dès qu'elle a au moins une méthode virtuelle pure.
On ne peut pas créer d'instance pour les classes abstraites.
Une classe abstraite est une classe implantant un concept général dont seules des spécialisations (à créer par dérivation) peuvent être utilisées.
Une classe dérivée d'une classe abstraite reste abstraite si elle ne redéfinit pas TOUTES les méthodes virtuelles pures dont elle hérite.

Polymorphisme 15

Liaison statique vs. liaison dynamique

Utiliser la liaison statique lorsque vous êtes surs que les classes dérivées n'auront pas la nécessité de redéfinir dynamiquement certaines fonctions membres.
Son utilisation est indiquée :
- pour construire des types de données concrets.
- lorsque l'on privilégie l'efficacité par rapport à la flexibilité.
Utiliser la liaison dynamique lorsque les classes dérivées pourront fournir une meilleure implémentation de certaines fonctions et qu'il est nécessaire de les sélectionner au moment de l'exécution.
Son utilisation est indiquée :
- pour construire des types de données abstraits.
- lorsque l'on privilégie la flexibilité par rapport à l'efficacité.

Polymorphisme 16

Exemple : Tri d'objets (1)

class Sortable {

public:

// retourne 0 si égaux

virtual int compare(Sortable const &) const=0;

virtual ~Sortable();

virtual int getsignature() const =0;

};

class Personne : public Sortable {

protected:

char nom[25];

int salaire;

public:

int compare(Sortable const &) const;

int getsignature() const;

~ Personne();

// ...

};

Polymorphisme 17

Exemple : Tri d'objets (2)

int Personne::getsignature() const {

// identificateur propre aux personnes

// static --> adresse de tag est unique

static int tag;

return (int &tag);

}

// retourne 0 si égaux

int Personne::compare(Sortable const & other) {

register int cmp;

// Vérif. comparaison de deux Personnes

if ((cmp = getsignature()

- other.getsignature()))

return cmp;

// conversion de Sortable en Personne

Personne const & o = (Personne const&) other;

if ((cmp = strcmp(nom,o.nom)) == 0)

return cmp;

return 1;

}