Nous utilisons couramment l'héritage public à des fins de réutilisation
Pour éviter de définir une classe à partir de zéro, on dérive notre classe
d'une classe existante qui procure un bon point de départ.
avec l'héritage public, TOUTES les méthodes (et attributs) de la classe de base
tombent automatiquement dans notre interface (partie publique de la classe).
L'héritage privé est un moyen de contrôler les méthodes que nous désirons exposer.
Source / Exemple :
/* ceci est sensé représenter un héritage public et deux héritages privés
----------
| A |
----------
| + f1 |
| + f2 |
----------
^ ^ ^
<<public>> <<private>> <<private>>
/ | \
---------- ---------- ----------
| BPub | | BPriv | | B |
---------- ---------- ----------
| + f1 | | - f1 | | + f1 |
| + f2 | | - f2 | | - f2 |
---------- ---------- ----------
#include <iostream.h>
class A{ //A est la Classe de Base
public:
void f1(){cout << "A::f1\n";};
void f2(){cout << "A::f2\n";};
};
class BPub : public A //BPub la classe dérivée de manière publique
{};//ici, rien à faire pour que f1 et f2 soient utilisables par des clients d'objets BPub
class BPriv : private A //BPriv la classe dérivée de manière privée
{};//ici, f1 et f2 ne sont pas utilisables par des clients d'objets BPriv
/ /bien sûr, les méthodes que l'on peut mettre dans la classe BPriv peuvent se servir de f1 et f2
// il y a donc quand même héritage
/* on voit que par défaut, aucune méthode n'est utilisable dans le 'main'
par l'objet de type BPriv : la solution est de redéfinir les méthodes
dont l'on souhaite garnir notre interface (ici f1)
on définira alors la classe B ainsi :
class B : private A
{public :
void f1(){cout << "B::f1 appelle "; A::f1();};
};
/*ceci permet l'utilisation de f1 avec une variable objet de type B,
alors que pour la même variable le compilateur bloque les appels à f2.
int main()
{
BPub pub;
pub.f1(); //OK
pub.f2(); //OK
BPriv priv;
// priv.f1(); //ici, erreur de compilation
//la méthode f1 est bien publique pour A, mais elle est devenue privée pour BPriv
B pubpriv;
pubpriv.f1();//ici possible d'appeler f1 (redevenue publique dans B)
//pubpriv.f2();//ici impossible d'appeler f2 (restée privée dans B)
return 0;
}
/* Application : le Design Pattern d'Adapteur
Pour cette partie, le prérequis est la connaissance des interfaces
(méthodes virtuelles pures)
Nous voyons que l'utilisateur de notre classe B ne voit que les méthodes
que nous voulons bien lui montrer. On peut en profiter pour renommer les
méthodes de A dans B
Par exemple, une classe mère de type Liste avec des méthodes f1 et f2
servant à inserer() et retirer() peuvent etre changée dans la classe
dérivée nommée Pile en empiler() et depiler() avec l'implémentation suivante :
void Pile::empiler(int i){Liste::inserer(1, i);}
int Pile::depiler(){Liste::retirer(1);}
On peut alors "Adapter" notre classe à un composant logiciel préexistant qui
appelle les méthodes présentées par une interface IPile (empiler et depiler)
il suffit ensuite de déclarer la classe comme implémentant IPile ainsi :
class Liste
{public:
void inserer(int position, int nombre);
int retirer(int position);
...
};
class IPile
{
virtual void empiler(int nombre)=0;
virtual int depiler()=0;
};
class B : private Liste, public IPile
{public :
void empiler(int nombre){Liste::inserer(1, i);
int depiler(){Liste::retirer(1);}
...
};
Remarquons que l'on peut aussi atteindre ce design avec une donnée membre privée et la simple délégation.
Attention à ne pas utiliser le polymorphisme avec cet héritage privé
car l'upcasting n'est plus implicite comme dans l'héritage public !
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.