Programmation C++ (débutant)/L'héritage

Le cours du chapitre 17 : L'héritage

L'heritage entre les classes

Une caractéristique clé de classes C + + est l'héritage. L'héritage permet de créer des classes, qui sont dérivées d'autres classes, de sorte qu'elles incluent automatiquement certains membres de ses classes "parents", ainsi que ses propres membres. Par exemple, nous allons supposer que nous voulons déclarer une série de classes qui décrivent les polygones comme notre CRectangle, ou CTriangle. Ells ont certaines propriétés communes, telles que les deux peuvent être décrites au moyen de seulement deux côtés : hauteur et la base.

Cela pourrait être représenté dans le monde des classes avec une classe de CPolygon partir de laquelle les deux autres dériveraient : CRectangle et CTriangle.

La classe CPolygon devrait contenir des membres qui sont communs aux deux types de polygone. Dans notre cas : largeur et hauteur. CRectangle et CTriangle seraient ses classes dérivées, avec des caractéristiques spécifiques qui se differencies d'un type de polygone à l'autre.

Les classes qui dérivent d'autres héritent tous les membres accessibles de la classe de base. Cela signifie que si une classe de base comprend un membre A et est dérivée dans une autre classe ayant un membre appelé B, la classe dérivée contiendra deux membres : A et B.

Afin de dériver une classe d'une autre, nous utilisons deux points (:) dans la déclaration de la classe dérivée en utilisant le format suivant : class derived_class_name: public base_class_name { /*...*/ };

Où derived_class_name est le nom de la classe dérivée et base_class_name est le nom de la classe sur laquelle elle est fondée. Le spécificateur d'accès public peut être remplacé par l'un des spécificateurs d'accès protégé et d'autres privés. Ce spécificateur d'accès limite le niveau le plus accessible pour les membres hérités de la classe de base : Les membres avec un niveau plus accessible seraient hérités avec ce niveau, tandis que les membres ayant un niveau d'accès égal ou plus restrifs gardent leur niveau restrictif dans la classe dérivée.

// derived classes
#include <iostream>
using namespace std;                        20
                                            10
class CPolygon {
  protected:
    int width, height;
  public:
    void set_values (int a, int b)
      { width=a; height=b;}
  };
 
class CRectangle: public CPolygon {
  public:
    int area ()
      { return (width * height); }
  };
 
class CTriangle: public CPolygon {
  public:
    int area ()
      { return (width * height / 2); }
  };
 
int main () {
  CRectangle rect;
  CTriangle trgl;
  rect.set_values (4,5);
  trgl.set_values (4,5);
  cout << rect.area() << endl;
  cout << trgl.area() << endl;
  return 0;
}

Les objets de la CRectangle classes et CTriangle contiennent chacun des membres hérités de CPolygon. Ce sont : largeur, hauteur et set_values ​​().

Le spécificateur d'accès protégé est similaire à celui de privé. Sa seule différence est : Quand une classe hérite d'une autre, les membres de la classe dérivée peuvent accéder aux membres protégés hérités de la classe de base, mais pas ses membres privés.

Comme nous voulions que la largeur et la hauteur soient accessibles par CRectangle et CTriangle et pas seulement par les membres de CPolygon, nous avons utilisé un accès protégé au lieu d'un accès privé.

Nous pouvons résumer les différents types d'accès en fonction de qui peut y accéder de la façon suivante :

Access	public	protected	private
membre de meme classe	oui	oui	oui
membres de classes derivée	oui	oui	non
pas membre	oui	non	non

Héritage simple

L'héritage, également appelé dérivation, permet de créer une nouvelle classe à partir d'une classe déjà existante, la classe de base (ou super classe). "Il est plus facile de modifier que de réinventer". La nouvelle classe ou classe dérivée (ou sous classe) hérite de tous les membres de la classe de base, qui ne sont pas privés, et ainsi réutilise le code déjà écrit pour la classe de base. On peut aussi lui ajouter de nouveaux membres ou redéfinir des méthodes.

Héritage multiple

En C + +, il est parfaitement possible qu'une classe hérite des membres de plus d'une classe. Cela se fait simplement en séparant les différentes classes de base par des virgules dans la déclaration de la classe dérivée. Par exemple, si nous avions une classe spécifique à imprimer sur l'écran (COutput) et nous voulions que nos classes , CRectangle et CTriangle heritent aussi de ses membres en plus de ceux des CPolygon nous pourrions écrire:

1 class CRectangle: public CPolygon, public COutput; 2 class CTriangle: public CPolygon, public COutput;

L exemple complet decrit ici.

// multiple inheritance
#include <iostream>
using namespace std;
class CPolygon {
  protected:
    int width, height;
  public:
    void set_values (int a, int b)
      { width=a; height=b;}
  };
class COutput {
  public:
    void output (int i);
  };
void COutput::output (int i) {
  cout << i << endl;
  }
class CRectangle: public CPolygon, public COutput {
  public:
    int area ()
      { return (width * height); }
  };
class CTriangle: public CPolygon, public COutput {
  public:
    int area ()
      { return (width * height / 2); }
  };
  int main () {
  CRectangle rect;
  CTriangle trgl;
  rect.set_values (4,5);
  trgl.set_values (4,5);
  rect.output (rect.area());
  trgl.output (trgl.area());
  return 0;
}

http://www.everyoneweb.fr/informatikplus/