Leçon 3 : Héritage IUP 2 Génie Informatique Méthode et Outils pour la Programmation Françoise Greffier

LES FORMES GEOMETRIQUES Où l’on propose une application permettant de : Dessiner un carré, un rectangle, un cercle, un triangle …. Associer au dessin : périmètre et surface.

CLASSE FORME enum categorie { carre, rectangle, cercle, triangle}; class figure {public: . . . void dessiner (void); double périmètre (void); double surface (void); private : categorie c; double a,b; point centre; };

IMPLANTATION double figure::surface(void) {switch c { case carre : return (a*a); case rectangle : return (a*b); . . . }

POURQUOI HERITER ? Relier des objets entre eux (famille) Factoriser des traitements (Réutilisabilité) Représenter le centre de la figure (généralisation) IDENTIFICATION DES OBJETS Un cercle (rayon) ne « ressemble » pas à un rectangle (diagonale) Faciliter l ’extension l’application (Extensibilité) On traite les ellipses

COMMENT HERITER ? HIERARCHIE DE CLASSES GESTION D’UNE Factorisation Toute figure géométrique a un centre Spécialisation (un objet est un cas particulier d ’un autre objet) Un carré est un cas particulier de rectangle Enrichissement (un objet a des propriétés propres) Un triangle rectangle comprend le calcul de l’hypoténuse

GRAPHE D’HERITAGE Figure Polygone Ellipse Hérite de Figure Polygone Ellipse Parallélogramme triangle Cercle Rectangle triangle rectangle

RELATION D’HERITAGE M Classe mère D Classe dérivée Héritage simple : La classe D hérite de la classe M Héritage simple : Un unique ascendant direct

Relation : « est une sorte de » HERITAGE PUBLIC Héritage public Relation : « est une sorte de » Les classes dérivées héritent de la classe mère en se spécialisant Les membres public de la classe mère deviennent des membres public des classes dérivées. Les classes dérivées peuvent avoir des membres supplémentaires. (enrichissement)

HERITAGE public en C++ public M class D: {public : Méthodes redéfinies : void f(void); Méthodes supplémentaires : void h(void); private: Caractéristiques supplémentaires }; public M class M {public : void f(void); void g(void); private: ... }; L ’instance W de la classe D a accès à la section public des classes D et M

Partage des caractéristiques class D: {public : ... private: Caractéristiques supplémentaires }; public M class M {public : ... protected : private: }; Pour la classe D : les membres de la section protected de la classe mère M sont accessibles par ses fonctions membres et fonctions amies Pour la classe M : les membres de la section protected se comportent comme s’ils étaient placés dans sa section private.

HERITAGE : public Partage des caractéristiques public M class D : {public : protected: private : }; class M {public : protected: private : }; Partie inaccessible héritée

Accès aux caractéristiques class D: {public : ... private: Caractéristiques supplémentaires }; public M class M {public : ... protected : private: }; accès aux sections public et protected de la classe M Classe D (ex: fonction main) accès aux sections public des classes M et D Vision utilisateur

Accès aux caractéristiques class D: {public : ... private: Caractéristiques supplémentaires }; public M class M {public : ... protected : private: }; Attention : l ’utilisation du qualificateur protected est contraire au principe d ’encapsulation. Si des modifications sont apportées à la section protected de la classe M alors toutes les classes dérivées qui utilisent l ’accès direct à cette section sont susceptibles de subir des modifications.

Les constructeurs class rectangle : public figure class figure rectangle(double,double,point); // constructeur par initialisation : //longueur et largeur, centre }; public figure class figure {public : figure (point); //construct :centre private : point centre; }; rectangle::rectangle(double a,double b,point c):figure (c) { lo=a; la=b; } Appel du constructeur de la classe mère

Les constructeurs Lors de la création d ’une instance d ’une classe dérivée son constructeur et tous les constructeurs de ses classes parentes sont activés. Héritage simple : Les constructeurs sont activés de la racine de l ’arbre d ’héritage vers les classes dérivées Activation : d ’un constructeur par défaut (qui doit exister) ou bien appel à un constructeur explicite.

Les destructeurs Lors de la destruction d’une instance d ’une classe dérivée son destructeur et tous les destructeurs de ses classes parentes sont activés. Héritage simple : Les destructeurs sont activés de la classe dérivée vers la racine de l ’arbre d ’héritage.

Fonctions polymorphes class D1: {public : void f(void); void h(void); private: Caractéristiques supplémentaires }; class D2 : {public : void f(void); void k(void); private: Caractéristiques supplémentaires }; class M {public : void f(void); void g(void); private : . . . Protected : }; public M public M Le polymorphisme offre la possibilité d ’associer à une méthode un code différent selon l’objet auquel elle appartient. Exemples : f ou tracer pour les formes géométriques

Fonctions polymorphes (Liaison statique) class D1: {public : void f(void); void h(void); ...}; public M class D2 : {public : void f(void); void k(void); …}; public M class M {public : void f(void); void g(void); private : . . . Protected : }; Comment dans une hiérarchie par héritage, le compilateur sélectionne la méthode polymorphe à exécuter parmi les surcharges incluses dans la hiérarchie de classes ? D1 w1; D2 w2; w1.f( ); w2.g( ); Vision utilisateur Liaison statique

Fonctions polymorphes (surcharge ) Liaison statique D1 w1; D2 w2; w1.f( ); w2.g( ); Vision utilisateur Classe M Classe D1 D2 Le type de W1 est D1, par conséquent le compilateur regarde si la méthode f est dans la classe D1 Si oui, celle-ci est exécutée Si non, il la recherche dans la première classe ascendante, etc... Résolution de la surcharge par liaison statique

Héritage et COMPATIBILITE de type class M { . . . }; class D : Vision utilisateur M* ptrM; D d; ptrM=&d; D* ptrD; M m; ptrD=&m; public M Par définition le type statique d’une expression est celui donné à la compilation. Le type dynamique d’une expression est déterminée par la valeur courante de l’expression, il peut changer en cours d’exécution. On dit que le type statique de *ptrM est M. On dit que le type dynamique de *ptrM est D. L’objet pointé par ptrM reste de type D.

Collection d’objets de types différents { figure* T[4]; // tableau de pointeurs // sur figure T[0]=new carré(); T[1]=new rectangle(); T[2]=new cercle(); T[3]=new triangle(); } Sur cet exemple, les composants du tableau T ont un type statique = figure un type dynamique = carré ou rectangle ...

Liaison statique des fonctions Vision utilisateur class figure { public : void tracer (void) { } //action vide }; class rectangle: void tracer (void); //rectangle IC est tracé figure* Ptr; Ptr = new rectangle(); Ptr -> tracer( ); Le type statique de *Ptr est figure. Par conséquent, l’instruction Ptr->tracer( ) active la méthode tracer de la classe figure. => public figure Il aurait fallu que la fonction appelée soit celle correspondant à l’objet pointé. Ce type étant dynamique : il ne faut pas que la fonction soit déterminée à la compilation. => Détermination dynamique à l’exécution  fonctions virtuelles Action vide

Liaison dynamique des fonctions Fonctions virtuelles Vision utilisateur class figure { public : void tracer (void) { } //action vide }; class rectangle : public figure void tracer (void); // instance courante est tracée figure* Ptr; Ptr = new rectangle( ); Ptr -> tracer( ); virtual La fonction tracer est virtuelle. Par conséquent, l’instruction Ptr->tracer( ); active la méthode associée au type dynamique de *ptr. => L’implémentation des fonctions virtuelles s’appuie sur une indirection virtual Tracé du rectangle

Les fonctions virtuelles Lors de la redéfinition d’une fonction virtuelle: Les fonctions virtuelles doivent avoir la même liste de paramètres. Les types de retour sont égaux ou sont des pointeurs compatibles. L’exécution des fonctions virtuelles s’appuie sur une indirection (table de pointeurs de fonctions virtuelles).

Les fonctions virtuelles Classes dérivées : Tout comme une fonction ordinaire une fonction virtuelle sert de fonction par défaut dans les classes dérivées. Une fonction virtuelle redéfinie dans une classe dérivée reste virtuelle dans la classe dérivée même si cela n’est pas spécifié.

Classe abstraite Une classe abstraite est une classe qui ne peut pas être instanciée exemple : L’instantiation de la classe figure n’a pas de sens. On ne peut pas tracer une figure, on tracera un carré, un cercle … => la méthode tracer est virtuelle pure Une classe qui comprend une fonction virtuelle pure et qui ne l’implémente pas est une classe abstraite. class figure { public : void tracer (void) ; }; virtual =0 //fonction virtuelle pure

Classe abstraite SYNTAXE : on indique qu’une méthode virtuelle est pure en ajoutant =0 en fin de spécification. class figure { public : void tracer (void) ; }; Une classe qui comprend une fonction virtuelle pure et qui ne l’implémente pas est une classe abstraite. virtual =0 //fonction virtuelle pure

UTILISATION D’UNE CLASSE ABSTRAITE Vision utilisateur class figure { public : virtual void tracer (void) =0; //fonction virtuelle pure }; figure F; figure* Ptr; Ptr = new figure; //illégal // légal //illégal L’instantiation de la classe figure n’a pas de sens. On en peut déclarer que des pointeurs sur figure. D ’une façon générale : L’instantiation d ’une classe abstraite n’a pas de sens. Elle est refusée à la compilation On en peut déclarer que des pointeurs sur une classe abstraite.