Partie 11: Héritage — Programmation orientée objet en C++

Programmation Orientée Objet en C++
11ème Partie: Héritage

Fabio Hernandez
Fabio.Hernandez@in2p3.fr

Vue d'Ensemble
Notions de base
Types, variables, opérateurs
Contrôle d'exécution
Fonctions
Mémoire dynamique
Qualité du logiciel
Evolution du modèle objet
Objets et classes
Fonctions membres
Classes génériques
Héritage
Polymorphisme
Héritage multiple
Entrée/sortie

POO en C++: Héritage 345 © 1997-2003 Fabio HERNANDEZ

Table des Matières

Motivation
Classification
Spécialisation
Redéfinition des fonctions membres
Conversions standards
Contrôle d'accès
Classe abstraite
Redéfinition des opérateurs
Résumé


Motivation

Assez souvent, les nouveaux logiciels sont basés sur des
développements précédents
Plusieurs approches
imitation
raffinement
combinaison
Le modèle objet tient compte de ce fait et offre des
mécanismes pour apporter une solution à ce problème
Les techniques étudiées jusqu'à présent ne sont pas suffisantes
Les classes constituent une bonne technique de décomposition
en modules


Motivation (suite)

Les classes possèdent plusieurs des qualités demandées aux
composants réutilisables
modules cohérents
séparation entre l'interface et l'implémentation
flexibilité des classes génériques
Davantage de qualités sont nécessaires pour atteindre les
objectifs de réutilisation et extensibilité
Nous avons besoin de mécanismes permettant d'exprimer les
caractéristiques et le comportement communs existants dans
des groupes de structures similaires, mais aussi de tenir
compte des différences qui caractérisent les cas particuliers


Motivation (suite)

Une classe peut être une extension, une spécialisation ou une
combinaison d'autres classes
Le modèle objet et les langages orientés objet fournissent des
mécanismes offrant des solutions à ces besoins via l'héritage
entre classes
L'héritage est un des composants fondamentaux de la
technologie objet


Contrôle d'avancement

Motivation
Classification
Spécialisation
Contrôle d'accès
Classe abstraite
Résumé


Classification

Nous voulons modéliser les comptes en banque
Un compte en banque a plusieurs caractéristiques intéressantes
pour notre modèle
titulaire
numéro d'identification
solde
date de création
Quelques opérations sont souhaitables sur un compte
obtenir le solde
faire un dépôt
faire un retrait
faire un virement sur un autre compte du même titulaire


Classification (suite)

Nous pouvons écrire l'interface de la classe compte en banque
en C++ comme

class BankAccount {
public:
// Constructors/Destructor
BankAccount(const std::string& owner);
~BankAccount();

// Modifiers
bool deposit(float amount);
bool withdraw(float amount);


// Selectors
float getBalance() const;
int getAccountNumber() const;
const std::string& getOwner() const;
const Date& getCreationDate() const;

private:
// Data members
std::string ownerName_;
float balance_;
Date creationDate_;
int accountNumber_;
};


L’implémentation du constructeur et du destructeur de cette
classe serait
BankAccount::BankAccount(const std::string& owner)
{
ownerName_ = owner;
balance_ = 0.0;
accountNumber_ = . . .; // Do something to assign a
// unique account number
}

BankAccount::~BankAccount()
{
// Nothing to do
}



Dans le monde réel il existe plusieurs types de comptes en
banque
compte de chèques
compte d'épargne
plan d'épargne logement
plan de ...
Notre modèle des comptes bancaires devrait refléter cette
réalité
Nous aurions tendance à modéliser chacun de ces types de
comptes comme une classe C++
class CheckingAccount {...};
class SavingAccount{...};
...



Comment refléter le fait que tous ces types de comptes ont des
caractéristiques communes
titulaire
solde
numéro d'identification
date de création
...
Mais aussi des caractéristiques particulières à chaque type
comme
la (im)possibilité de retrait
taux d'intérêt
solde minimum
...



Avec les mécanismes étudiés jusqu'à présent nous avons deux
possibilités:
dupliquer le code nécessaire pour modéliser ces caractéristiques
communes
faire en sorte que la classe modélisant les caractéristiques communes
soit contenue dans les autres classes
La première possibilité n'est pas envisageable parce qu'elle
suppose tous les inconvénients de la duplication de code
Considérons la deuxième: la classe SavingAccount contient un
attribut de la classe BankAccount
la mission de cet attribut est d'encapsuler toute l'information relative à
un compte bancaire générique (titulaire, solde, ...)


class SavingAccount {
public:
SavingAccount(const std::string& owner);
~SavingAccount();

// Modifiers
bool setInterestRate(float newRate);


// Selectors
float getInterestRate() const;

private:
// Data members La classe
BankAccount account_; BankAccount est
float interestRate_; contenue dans
}; SavingAccount



L'implémentation des méthodes de la classe SavingAccount
serait comme

float SavingAccount::getBalance() const
{
return account_.getBalance();
} Ces méthodes
délèguent leur
bool SavingAccount::deposit(float amount) implémentation
{ à l'attribut
account_
return account_.deposit(amount);
}



Implémentation de la classe SavingAccount (suite)
float SavingAccount::getInterestRate() const
{
return interestRate_;
}
La classe CheckingAccount pourrait être implémentée d'une
façon similaire
L'avantage de cette approche est la réutilisation sans
duplication du code
Son principal inconvénient est qu'une modification dans la
classe BankAccount suppose des modifications dans toutes les
classes qui utilisent ses services (SavingAccount,
CheckingAccount,...)



Le modèle objet fournit un mécanisme qui permet à une classe
d'hériter les attributs et méthodes d'une autre classe et
d'étendre ses fonctionnalités si nécessaire
Dans ce contexte nous pourrions définir la classe
SavingAccount comme "une sorte de" BankAccount
Ce type de relation entre classes est connu comme une relation
est-un (is-a), par opposition à une relation contient-un (has-a)
Dans l'exemple précédent, la classe SavingAccount contient
un BankAccount
Regardons maintenant le mécanisme fournit par C++ pour
exprimer la relation est-un



Motivation
Classification
Spécialisation
Contrôle d'accès
Classe abstraite
Résumé


Spécialisation

Nous allons modéliser les classes SavingAccount et
CheckingAccount comme une spécialisation de la classe
BankAccount

BankAccount

SavingAccount CheckingAccount


Spécialisation (suite)
class SavingAccount: public BankAccount {
public:
Définition de
SavingAccount(const char* owner);
SavingAccount
~SavingAccount();
comme une
// Modifiers spécialisation de
BankAccount

// Selectors

private:
// Data members
float interestRate_;
};



Un objet de la classe SavingAccount hérite les attributs et
services de la classe BankAccount

BankAccount SavingAccount
ownerName_: std::string
balance_: float interestRate_: float
creationDate_: Date
accountNumber_: int getInterestRate: float
deposit: bool setInterestRate: bool
withdraw:bool
getBalance: float
getAccountNumber: int
getOwner: std::string
getCreationDate: const Date&



Un objet déclaré comme
SavingAccount account;
est composé des attributs de la classe BankAccount et de la
classe SavingAccount

ownerName_: std::string Attributs de la
balance_: float partie
creationDate_: Date BankAccount
accountNumber_: int

interestRate_: float Attributs de la
partie
account SavingAccount



De façon similaire, un objet de la classe SavingAccount hérite
les services de la classe BankAccount
Nous pouvons donc écrire
// Create a SavingAccount object
SavingAccount account("Jacques Cousteau");
// Deposit an amount into this account
account.deposit(500.0);
// Print its new balance
cout << "The balance is " << account.getBalance();
// Set its interest rate
account.setInterestRate(0.03);



BankAccount

deposit: bool
Classe de base ou
withdraw: bool
SuperClasse
getBalance: float
getAccountNumber: int
getOwner: std::string
getCreationDate: const Date&

SavingAccount
Classe dérivée ou
setInterestRate: bool Sous-Classe
getInterestRate: float


L'implémentation de la classe SavingAccount est composée
des fonctions membres particulières à cette classe
bool SavingAccount::setInterestRate(float newRate)
{
interestRate_ = newRate;
return true;
}
// Constructor
SavingAccount::SavingAccount(const std::string& owner)
: BankAccount(owner) Initialisation de
{ la partie
interestRate_ = 0.0; BankAccount
}



La liste d'initialisation des attributs est utilisée pour passer les
arguments nécessaires au constructeur de la classe de base
Dans cet exemple
BankAccount n'a pas de constructeur par défaut
SavingAccount est une spécialisation de BankAccount
Pour créer un objet de la classe SavingAccount il est nécessaire
d'initialiser sa partie BankAccount
Si la classe de base a un constructeur par défaut et la liste
d'initialisation des attributs n'est pas spécifiée, c'est le
constructeur par défaut qui sera utilisé pour créer la partie de
l'objet correspondante à la classe de base



Motivation
Classification
Spécialisation
Contrôle d'accès
Classe abstraite
Résumé



L'implémentation de BankAccount::withdraw pourrait être

bool BankAccount::withdraw(float amount)
{
if (balance_ < amount)
return false;

balance_ -= amount;
return true;
}
Celle-ci est une implémentation générique d'une opération de
retrait


Redéfinition des fonctions membres (suite)

Certains types de comptes bancaires imposent des restrictions
sur
le montant du retrait
le solde minimum
...
C'est le cas de notre compte d'épargne: un compte de ce type
exige un solde minimum
La fonction membre BankAccount::withdraw ne peut pas
être utilisée telle quelle par la classe SavingAccount
SavingAccount doit définir sa propre opération
SavingAccount::withdraw


class SavingAccount: public BankAccount {
public:
SavingAccount(const std::string& owner);
~SavingAccount();

// Modifiers

// Selectors
Redéfinition de
BankAccount::withdraw
private:
// Data members
float interestRate_;
};


bool SavingAccount::withdraw(float amount)
{
const float MinimumBalance = 500.0;
if ((getBalance() - MinimumBalance) < amount)
return false;

return BankAccount::withdraw(amount);
}
Appel explicite à la
fonction membre
withdraw de la
classe de base



BankAccount

deposit: bool
withdraw: bool
getBalance: float
getAccountNumber: int La sous-classe
getOwner: const std::string spécialise une des
creationDate: const Date& fonctions membres
de la classe de
base

SavingAccount

setInterestRate: bool
getInterestRate: float
withdraw: bool


Motivation
Classification
Spécialisation
Contrôle d'accès
Classe abstraite
Résumé



Quelques conversions standards sont appliquées entre un objet
d'une sous-classe et sa classe de base
valable uniquement dans le cas d'héritage avec attribut public
Un objet de la sous-classe peut être implicitement traité
comme un objet de la classe de base
Un pointeur (ou une référence) à un objet de la sous-classe peut
être traité comme un pointeur (ou une référence) à un objet de
la classe de base
SavingAccount savingsAccount("Tantine Riche");
// the 'savingsAccount' object is a kind of BankAccount
BankAccount* bankAccountPtr = &savingsAccount;
BankAccount& bankAccountRef = &savingsAccount;


Conversions standards (suite)

Un objet d'une classe dérivée est composé
d'une partie correspondante à la classe de base
d'une partie spécifique à la sous-classe
Ces conversions implicites sont acceptées parce qu’un objet
d'une classe dérivée "contient" un objet de la classe de base



Motivation
Classification
Spécialisation
Contrôle d'accès
Classe abstraite
Résumé


Contrôle d'accès

Bien que l'attribut BankAccount::balance_ soit un des
composants de la classe SavingAccount, aucune des fonctions
membres de SavingAccount n'y a accès, parce qu'il a été
déclaré privé
Si nous ajoutons la fonction membre computeProfit à la
classe SavingAccount
float SavingAccount::computeProfit() const
{
// COMPILATION ERROR: balance_ is a private
// attribute of BankAccount
return interestRate_ * balance_;
}


Contrôle d'accès (suite)

Nous devons écrire
{
return interestRate_ * getBalance();
}

Utilisation de
BankAccount::getBalance()



Il est parfois souhaitable qu'une fonction membre d'une sous-
classe ait accès directement aux attributs de la classe de base
Un attribut ou méthode déclaré protected est accessible
uniquement par les sous-classes
class BankAccount {
public:
...
protected: Ce mécanisme donne
// Data members accès aux données
std::string& ownerName_; membres de
float balance_; BankAccount à
Date creationDate_; toutes ses sous-
int accountNumber_; classes
};



Les fonctions membres de SavingAccount ont maintenant
accès aux données membres de la partie de l ’objet
correspondante à la classe BankAccount
{
// OK: balance_ is a protected attribute
// of BankAccount
return interestRate_ * balance_;
}
Cependant l'accès à ces attributs reste toujours restreint
BankAccount account;
account.balance_ = 200.0;
// COMPILATION ERROR: balance_ is protected



Un attribut(fonction) membre déclaré(e) protected est
accessible par les fonctions membres d'une classe dérivée, mais
il(elle) reste privé(e) pour le reste du programme



Motivation
Classification
Spécialisation
Contrôle d'accès
Classe abstraite
Résumé


Classe abstraite

Nous avons créé la classe BankAccount afin de "factoriser" les
attributs et le comportement communs de tous les types de
comptes en banque dans le but de les réutiliser dans les sous-
classes
En conséquent, nous ne devrions pas avoir besoin de créer un
objet de la classe BankAccount comme dans
BankAccount account("Marcel Marceau");
cout << account.getBalance() << endl;
puisqu'il ne représente pas un objet du domaine du problème
que nous modélisons
Autrement dit, cette classe n'a lieu d'exister qu'en tant que
composante d'une classe dérivée comme SavingAccount ou
CheckingAccount


Classe abstraite (suite)

Nous pouvons utiliser les mécanismes de contrôle d'accès pour
empêcher qu'une instance de la classe BankAccount puisse
être créée
class BankAccount {
public:
// Modifiers

// Selectors



protected:

BankAccount(const std::string& owner);
~BankAccount();
Impossible de créer une
// Data members instance de cette classe:
std::string ownerName_; le constructeur et le
float balance_;
destructeur sont
protégés
Date creationDate_;
int accountNumber_;
};



Maintenant, les services de la classe BankAccount ne peuvent
être utilisés que par ses sous-classes

#include "BankAccount.h"

int main() {
BankAccount account("Marcel Marceau");
// COMPILATION ERROR: the constructor
// of BankAccount is protected
return 0;
}



Motivation
Classification
Spécialisation
Contrôle d'accès
Classe abstraite
Résumé



Une sous-classe hérite toutes les fonctions membres de sa
classe de base sauf
les constructeurs
le destructeur
les opérateurs
Les constructeurs ne sont pas hérités directement mais sont
utilisés dans la liste d'initialisation des constructeurs de la
sous-classe
Le destructeur est utilisé automatiquement à la destruction de
l'objet
Les opérateurs doivent être redéfinis par la sous-classe en
appelant ceux de la classe de base


Redéfinition des opérateurs (suite)
class Base {
public:
...
bool operator==(const Base& aBase) const;
Base& operator=(const Base& aBase);
...
private:
int data_;
};


bool Base::operator==(const Base& aBase) const
{
return (data_ == aBase.data_) ? true : false;
}

Base& Base::operator=(const Base& aBase)
{
if (this == &aBase)
return *this;

data_ = aBase.data_;
return *this;
}


class Derived: public Base {
public:
...
bool operator==(const Derived& aDerived) const;
Derived& operator=(const Derived& aDerived);
...
private:
float ratio_;
};


bool Derived::operator==(const Derived& aDerived) const
{
return ( Base::operator==(aDerived) &&
(ratio_ == aDerived.ratio_)) ? true : false;
}

Derived& Derived::operator=(const Derived& aDerived)
{
if (this == &aDerived)
return *this; Utilisation des
Base::operator=(aDerived); opérateurs de la
ratio_ = aDerived.ratio_;
classe de base dans
l'implémentation des
return *this;
opérateurs de la sous-
} classe



Motivation
Classification
Spécialisation
Contrôle d'accès
Classe abstraite
Résumé


Résumé

L'héritage permet de définir de nouvelles classes par
extension, spécialisation ou combinaison d'autres déjà définies
Une classe dérivée (ou sous-classe) hérite ses attributs et
fonctions membres de la classe de base(ou super-classe)
Une sous-classe peut redéfinir les fonctions membres de la
classe de base
Des mécanismes de contrôle d'accès permettent aux sous-
classes d'accéder aux attributs de la classe de base tout en
préservant l'encapsulation
Une classe abstraite en est une qui ne peut être utilisée que
comme classe de base
Les opérateurs doivent être redéfinis par les sous-classes


Partie 11: Héritage — Programmation orientée objet en C++

Contenu connexe

Tendances (20)

En vedette (10)

Similaire à Partie 11: Héritage — Programmation orientée objet en C++ (20)

Dernier (7)

Partie 11: Héritage — Programmation orientée objet en C++