1/notion d'heritage

=>class derived ::type_d'heritage base

2/utilisation des membres de la classe de base dans la classe derivée

=>
lorsque l'heritage est public :les membres public de la classe de base sont des
membres publics de la classe
dérivées
**régle:Une méthode d’une classe dérivée n’a pas accès aux membres privés de sa
classe de base.
mais en revanche une methode de la classe derivées a accées aux membre publics de
sa classe de base c'est
pour cela qu'on appelle les fonctions de la classe de base pour afficher ses membre
privées
exemple : void pointcol::affichec ()
{ affiche () ;
cout << " et ma couleur est : " << couleur << "\n" ;
}

3/redéfinition d'une classe derivée

3-1/redefinition des fonctions :
=>
lors de la redéfinition d'une class derivee avec le meme nom que la classe de base
on ne peut
exemple : void pointcol::affiche ()
{ point::affiche () ; // appel de affiche de la classe point
cout << " et ma couleur est : " << couleur << "\n" ;
}

3-2/redefinition des membres données :

si la classe derivée contient une attribut qui a le meme nom que la classe de base
alors lors de l'appelle
b.a avec a de type int dans classe de base et de float dans la classe dérivée le
compilateur fait appel à a
de la classe dérivée
class A
{ .....
int a ;
char b ;
.....
} ;
class B : public A
{ float a ;
.....
} ;
Dans ce cas, si l’objet b est de type B, b.a fera référence au membre a de type
float de b. Il
sera toujours possible d’accéder au membre donnée a de type int (hérité de A) par
b.A::a
3-3/ redefinition et surdefinition :
exemple 1:
class A
{ public :
void f(int n) { ..... } // f est surdéfinie
void f(char c) { ..... } // dans A
};
class B : public A
{ public :
void f(int n) { ..... } // on redéfinit f(int) dans B
 } ;
main()
{ int n ; char c ; B b ;
b.f(n) ; // appelle B:(int)
b.f(c) ; // appelle B:f(int)
}
exemple 2:
class A
{ public :
void f(int n) { ..... }
void f(char c) { ..... }
} ;
class B : public A
{ public :
void f(int, int) { ..... }
main()
{ int n ; char c ; B b ;
b.f(n) ; // erreur de compilation
b.f(c) ; // erreur de compilation
}

Remarque :
Il est possible d’imposer que la recherche d’une fonction surdéfinie se fassse dans
plusieurs classes en utilisant une directive using.
Par exemple, si dans la classe A précédente,on introduit (à un niveau public)
l’instruction : using A::f ; // on réintroduit les fonctions f de A
l’instruction b.f(c) conduira alors à l’appel de A::f(char) (le comportement des
autres appels restant, ici, le même).

4/appel de constructeurs et destructeurs

voir cahier

5/controles d'accées
voir cahier

6/compatibilite entre classe derivée et classe de base

objet de la classe de base = objet de la classe derivée

7/constructeur de recopie et heritage

8/operateur d'affectation et heritage

9/heritage et forme canonique

10/heritage et ses limites

est ce que la classe de base peut utiliser les membres de sa classe derivée
=>oui mais il se limite juste pour les choses partages entre eux de membres privées