Héritage [185-207]

Dérivation / Héritage : sommaire

Héritage 1

Héritage

Objectifs de la programmation par objets :

abstraction des données,
réutilisation, ...

--> Classes, Héritage

Héritage 2

Définition et rôle

Le mécanisme d'héritage (appelé aussi dérivation) permet à une classe (appelée classe ``dérivée'') d'hériter des données membres et des fonctions membres d'une classe déjà définie (appelée classe de ``base'').
L'héritage est utilisé essentiellement pour :
- la spécialisation : la classe dérivée est un cas particulier de la classe de base, avec des propriétés supplémentaires et/ou redéfinition de comportements.
  
  Ex : 2-roues dérivée-de véhicule,
  
  rectangle dérivée-de figure
- l'implémentation : la classe dérivée réalise une implémentation particulière des services définis par la classe de base.
  Ex : liste implantée par chaînage dérivée-de liste abstraite
- l'utilisation : la classe dérivée utilise la classe de base pour implémenter ses propre services, qui sont différents de ceux de la base.
  Ex : pile dérivée-de liste

Héritage 3

Classe dérivée

La classe dérivée est constituée des attributs et des méthodes de la classe de base, + des membres ajoutés (données et/ou fonctions).
Le type dérivé se comporte de la même manière que le type de base, excepté pour :
- les membres ajoutés,
- les fonctions membres redéfinies, c.-à-d. implémentées différemment,
- les membres dont les droits d'accès ont été modifiés.
Une classe dérivée peut être elle-même utilisée comme base d'autres dérivations.

Héritage 4

Dérivation

class nom : á liste_de_dérivation ñ

{

// ...

};

liste_de_dérivation : liste des classes de base dont la classe dérivée hérite, avec les types de dérivation (cf. plus loin).
C++ supporte :
- l'héritage simple : une seule classe dans la liste de dérivation,
- l'héritage multiple (cf. plus loin) : plusieurs classes (différentes, avec des types de dérivation éventuellement différents) dans la liste de dérivation.

Héritage 5

Dérivation : exemple (1)

class `figure {`
protected `:`
Point `position ;`
public `:`
void `translater(`const int`,` const int`) ;`
void `afficher(`void`)` const `;`
`//` `...`
`} ;`

class `rectangle` `:` public `figure` `{`
`// Ajout d'attributs`
int `largeur, hauteur;`
public `:`
`// constructeur de rectangle`
`rectangle(`int `i=0,` int `j=0) :`
	`largeur(i), hauteur(j) {}`
`// ajout de méthode`
int `diagonale(`void`)` const `;`
`// redéfinition de méthode`
void `afficher(`void`)` const `;`
`// translater() n'est pas redéfinie`
`//` `...`
`} ;`

Héritage 6

Dérivation : exemple (2)

membres	position
hérités de figure	translater(const int, const int)
	figure::afficher()
	largeur
membres spécifiques	hauteur
à rectangle	diagonale()
	afficher()

rectangle rect(5,10);

// appel ``afficher'' de la classe ``rectangle''

rect.afficher();

// appel ``afficher'' de la classe ``figure''

rect.figure::afficher();

rect.translater();

Héritage 7

Dérivation et droits d'accès

classBase {private: // membres privés

utilisation réservée aux fonctions membres et amies de la classe.

protected: // membres protégés

utilisation autorisée aux fonctions membres et amies d'une classe dérivée.

public: // membres publics

utilisation par n'importe quelle fonction.

};

Héritage 8

Accès aux membres (1)

Soit une classe Deriv dérivée-de Base.

Deriv a accès aux membres publics et protégés qu'elle hérite de Base, mais n'a pas accès aux membres privés dont elle hérite.
Les membres hérités accessibles sont accédés comme s'ils étaient des membres de la classe dérivée, ou bien via l'opérateur de portée (Base::).
vis-à-vis des instances de Base, Deriv a des droits d'accès ordinaires (les mêmes que les autres classes).
le type de dérivation peut modifier les droits d'accès des membres hérités (cf. plus loin).

Héritage 9

Redéfinition des membres (1)

Soit une classe Deriv dérivée-de Base.

Une méthode héritée de Base peut être redéfinie dans Deriv en déclarant une méthode dans Deriv avec la même signature.

MAIS, il faut savoir que :

Toute déclaration dans Deriv d'un membre ayant MEME NOM qu'un membre hérité de Base ``masque'' ce membre.
Þ le membre hérité n'est plus accessible directement depuis Deriv (masquage lexical).
--> utiliser Base::nom_membre pour y accéder.
Ceci est vrai même si ce sont des méthodes ayant une signature et/ou un type de retour différents.
(Ce phénomène de masquage n'empêche pas d'hériter de plusieurs méthodes de même nom.)

Héritage 10

Redéfinition des membres : exemple (1)

class Auto {

public:

Auto(int x) : poids(x) {}

void setpoids(int x) { poids=x; }

int getpoids(void) { return poids; }

// ...

private:

int poids;

// ...

};

class Camion : public Auto {

private:

int remorque; // poids de la remorque

// ...

public:

Camion(int x, int y) : Auto(x), remorque(y) {}

void setpoids(int, int);

int getpoids(void);

// ...

};

Héritage 11

Redéfinition des membres : exemple (2)

void Camion::setpoids(int x, int y) {

// setpoids masque setpoids de Auto

// Accès à setpoids de Auto par :

Auto::setpoids(x);

remorque = y;

}

int Camion::getpoids(void) {

// Accès à getpoids de Auto

return Auto::getpoids()+remorque;

}

Héritage 12

Types de dérivation (1)

Dérivation publique :
class Deriv : public Base { ...};
- Þ protections inchangées dans Deriv pour les membres protégés et publics hérités de Base.
Dérivation protégée :
class Deriv : protected Base { ...};
- Þ les membres publics de Base deviennent protégés dans Deriv (les membres protégés le restent).
Dérivation privée (par défaut) :
class Deriv : private Base { ...};
- Þ les membres protégés et publics de Base deviennent privés dans Deriv.

--> Rappel : quel que soit le type de dérivation, les membres privés de Base ne sont pas accessibles dans Deriv.

Héritage 13

Types de dérivation (2)

Principes de dérivations :

Utiliser une dérivation publique lorsque la classe dérivée est une spécialisation de la classe de base : les services offerts par la classe de base doivent pouvoir être accédés directement par les utilisateurs des classes dérivées.
Ex : rectangle dérivée-de figure
Utiliser une dérivation privée lorsque la classe de base sert uniquement comme élément de construction au sein de la classe dérivée (utilisation) : les services de la classe de base sont utilisés pour simplifier la conception de la classe dérivée.
Ex : pile dérivée-de liste
Utiliser une dérivation protégée lorsque la classe de base sert d'élément de construction mais doit pouvoir être utilisée lors de dérivations futures.

Héritage 14

Types de dérivation (3)

Exemptions individuelles :

Pour une dérivation protégée ou privée, on peut exempter certains membres de l'accroissement de protection du au type de dérivation :

class `String {`
private`:`
void `foo();`
public`:`
`// ...`
int `length()` const `;`
void `yafoo();`
`};`

class `Nom :` private `String {`
public`:`
`// ...`
`String::length; // déclaration d'accès`
	`// (ni type ni signature)`
protected`:`
`String::yafoo;`
`String::foo` `; // ERREUR : le droit d'accès`
`// à` foo `ne peut pas être augmenté !!!`
`};`

Héritage 15

Dérivation et conversion (1)

Dans le cas d'une dérivation publique, la conversion automatique est possible : la classe dérivée est une spécialisation de la classe de base
Þ conversion Deriv -> Base est toujours possible.

void fonc(figure);

rectangle rect ;

// Exples de conversion automatique

// de rectangle -> figure

figure f = rect ;

figure *ptFig = &rect ;

figure& ptFig = rect ;

fonc(rect);
--> conversion réciproque (Base -> Deriv) automatique seulement s'il existe un constructeur Deriv::Deriv(const Base&)
Dans le cas d'une dérivation privée pas de conversion automatique.
Dans le cas d'une dérivation protégée, conversion automatique Deriv -> Base seulement dans la portée de Deriv.

Héritage 16

Dérivation et conversion (2)

`//` class `Camion :` public `Auto { } ;`
`Auto a(900);`
`Camion c(1200,130);`

`a = c; // ok`

`// si pas d'opérateur de conversion`
`// d'une classe de base en une classe`
	`dérivée : Camion(Auto&)`
`c = a; // erreur`

`// conversion implicite`
`Auto *aptr = &c;`
`cout` `<<` `aptr->getpoids(); // Auto::getpoids`

`// conversion explicite`
`Camion cptr = (Camion ) aptr;`
`cout` `<<` `cptr->getpoids(); // Camion::getpoids`

Héritage 17

Dérivation et constructeurs

Les constructeurs ne sont pas hérités.
Par défaut, chaque création d'une instance dérivée invoque implicitement le constructeur sans argument de la classe de base.
MAIS on peut invoquer explicitement (dans la liste d'initialisation du constructeur de la classe dérivée) un constructeur avec arguments de la classe de base pour initialiser les membres hérités :
Deriv::Deriv(arg_list) :Base(arg_base) {}
Ordre d'appel des constructeurs :
1. constructeurs des classes de base (selon ordre de la liste de dérivation),
2. constructeurs des objets membres (selon ordre de la déclaration dans la classe),
3. constructeur de la classe dérivée.

Héritage 18

Dérivation et destructeurs

Le destructeur n'est pas hérité.
MAIS chaque destruction d'une instance dérivée invoque implicitement le destructeur de la classe de base.
Ordre d'appel des destructeurs est l'ordre inverse de l'appel des constructeurs :
1. destructeur de la classe dérivée,
2. destructeurs des objets membres (ordre inverse de déclaration dans la classe),
3. destructeurs des classes de base.

Héritage 19

Dérivation et opérateurs

Les opérateurs membres sont hérités comme des méthodes ordinaires,
SAUF l'opérateur d'affectation (=), qui n'est pas hérité.
L'affectation d'une instance dérivée dans une instance de base est permise. L'inverse ne l'est pas : toute affectation impliquant une perte de données est permise alors qu'une affectation introduisant des données indéfinies est interdite.
ATTENTION AU TYPE DE RETOUR des opérateurs...

class Base { ...

public:

Base& operator++();

};

class Deriv : public Base {...};

...

Deriv d1, d2;

d2 = ++d1 ; // Erreur : ++d1 retourne

// un Base&
ATTENTION à l'héritage des opérateurs new et delete

Héritage 20

Dérivation et amitié

Soit une classe Deriv dérivée-de Base.

Une fonction (ou classe) amie de la classe de base Base a accès à tous les membres hérités de la classe dérivée Deriv (mais pas aux nouveaux membres),
Une fonction (ou classe) amie de la classe dérivée Deriv a les mêmes droits d'accès vis-à-vis de la classe de base Base que les méthodes de Deriv.
La relation d'amitié n'est pas héritée :

class A {

   int a;

   //...

friend class C;

};

class D : public C {

   void f(A* p) { p->a++; } // Erreur

};

Héritage 21

Héritage multiple

Cas où une classe dérive de plusieurs classes de base.

Permet de combiner le comportement des différentes classes de base

class PointWithLabel : publicPoint,publicLabel {...};
conflit de nom possible :
par exemple, si Point et Label définissent toutes les deux une méthode print()
PointWithLabel pl; pl.print(); // Erreur : ambigu

Þ 2 possibilités :
1. préciser pour chaque appel laquelle on veut (Point::print() ou Label::print())
2. redéfinir une méthode print() dans la classe dérivée (qui appelle explicitement une des 2, ou les 2, ou accepte un paramètre permettant de choisir...)

Héritage 22

Classe de base virtuelle (1)

class Deriv1 : public Base {...}; ,

class Deriv2 : public Base {...};

class Fille :public Deriv1,publicDeriv2 {...};

Þ Fille contient 2 fois les membres de Base

Deux solutions :

pour membres venant de Base, toujours utiliser :: pour préciser si on parle d'un membre hérité via Deriv1 ou via Deriv2
utiliser l'héritage virtuel :

class Deriv1 : virtual public Base {...};

class Deriv2 : virtual public Base {...};

class Fille:public Deriv1,public Deriv2 {..};

Þ dans Fille, 1 seul exemplaire des membres provenant de Base

Héritage 23

Classe de base virtuelle (2)

Précisions sur l'héritage virtuel :

Dans la classe Fille, les attributs provenant de l'héritage virtuel ne sont pas initialisés par les classes intermédiaires Deriv1 ou Deriv2
MAIS Fille peut initialiser explicitement sa partie provenant de Base dans la liste d'initialisation de ses constructeurs :
Fille::Fille(argF) : Base(argB), Deriv1(argD1), Deriv2(argD2) {...}
Droits d'accès aux membres hérités virtuellement : ceux du chemin d'héritage le MOINS restrictif.

Ex :	`2-roues` dérivée-de `véhicule`,
`rectangle` dérivée-de `figure`

class `Base { ...`
public:
`Base& operator++();`
`};`
class `Deriv :` public `Base {...};`
`...`
`Deriv d1, d2;`
`d2 = ++d1 ; // Erreur : ++d1 retourne`
			`// un Base&`