Héritage C++


L'un des concepts les plus importants de la programmation orientée objet est l'héritage. L'héritage nous permet de définir une classe basée sur une autre classe, ce qui facilite la création et la maintenance d'une application. Cela a également pour effet de réutiliser les fonctions de code et d'améliorer le temps d'exécution.

Lors de la création d'une classe, vous n'avez pas besoin de réécrire de nouvelles données membres et fonctions membres, il vous suffit de spécifier que la nouvelle classe hérite des membres d'une classe existante. Cette classe existante est appelée classe de base, et la nouvelle classe est appelée classe dérivée.

l'héritage représente la est une relation. Par exemple, les mammifères sont des animaux, les chiens sont des mammifères, donc les chiens sont des animaux, et ainsi de suite.

Classe de base et classe dérivée

Une classe peut être dérivée de plusieurs classes, ce qui signifie qu'elle peut hériter des données et des fonctions de plusieurs classes de base. Pour définir une classe dérivée, nous utilisons une liste dérivée de classes pour spécifier la classe de base. La liste dérivée de classe porte le nom d'une ou plusieurs classes de base et a la forme suivante : 

class derived-class: access-specifier base-class

où le spécificateur d'accès est public, protégé ou privé où One , base-class est le nom d'une classe définie auparavant. Si le spécificateur d'accès n'est pas utilisé, la valeur par défaut est privée.

Supposons qu'il existe une classe de base Shape et Rectangle est sa classe dérivée comme suit : 

#include <iostream>
 
using namespace std;

// 基类
class Shape 
{
   public:
      void setWidth(int w)
      {
         width = w;
      }
      void setHeight(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};

// 派生类
class Rectangle: public Shape
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};

int main(void)
{
   Rectangle Rect;
 
   Rect.setWidth(5);
   Rect.setHeight(7);

   // 输出对象的面积
   cout << "Total area: " << Rect.getArea() << endl;

   return 0;
}

Lorsque le code ci-dessus est compilé et lorsqu'il est exécuté , il produit les résultats suivants :

Total area: 35

Contrôle d'accès et héritage

Une classe dérivée peut accéder à tous les membres non privés de la classe de base. Par conséquent, si les membres de la classe de base ne souhaitent pas être accessibles aux fonctions membres des classes dérivées, ils doivent être déclarés privés dans la classe de base.

Nous pouvons résumer différents types d'accès en fonction des droits d'accès, comme suit :

访问publicprotectedprivate
同一个类yesyesyes
派生类yesyesno
外部的类yesnono

Une classe dérivée hérite de toutes les méthodes de la classe de base, avec les exceptions suivantes :

  • Le constructeur, le destructeur et le constructeur de copie de la classe de base.

  • Opérateurs surchargés pour les classes de base.

  • Fonction ami de la classe de base.

Types hérités

Lorsqu'une classe est dérivée d'une classe de base, la classe de base peut être héritée en tant que publique, protégée ou privé Plusieurs types. Les types hérités sont spécifiés via le spécificateur d'accès expliqué ci-dessus.

Nous n'utilisons presque jamais l'héritage protégé ou privé et utilisons généralement l'héritage public. Lorsque vous utilisez différents types d'héritage, suivez les règles suivantes :

  • Héritage public (public) : Quand une classe dérive de public Lorsqu'elle est une classe de base, les membres publics de la classe de base sont également les membres publics de la classe dérivée, et les membres protégés de la classe de base sont également les membres protégés de la classe dérivée, les membres privés de la classe de base ne sont pas directement accessibles par la classe dérivée, mais sont accessibles en appelant le public< de la classe de base. 🎜> et protégés membres.

  • Héritage protégé : Lorsqu'une classe est dérivée d'une classe de base protégée, le public et < Les membres 🎜>protégés deviendront des membres protégés de la classe dérivée.

  • Héritage privé :

    Lorsqu'une classe est dérivée d'une classe de base privée, le public et < Les membres 🎜>protégés deviendront des membres privés de la classe dérivée.

    Héritage multiple
L'héritage multiple signifie qu'une sous-classe peut avoir plusieurs classes parents et qu'elle hérite des caractéristiques de plusieurs classes parents.

Les classes C++ peuvent hériter des membres de plusieurs classes. La syntaxe est la suivante : 

class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
<派生类类体>
};

Où, la méthode d'héritage du modificateur d'accès est

publique, protégée

ou

privée. L'un d'eux permet de modifier chaque classe de base, séparés par des virgules, comme indiqué ci-dessus. Regardons maintenant ensemble l'exemple suivant : 

#include <iostream>
 
using namespace std;

// 基类 Shape
class Shape 
{
   public:
      void setWidth(int w)
      {
         width = w;
      }
      void setHeight(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};

// 基类 PaintCost
class PaintCost 
{
   public:
      int getCost(int area)
      {
         return area * 70;
      }
};

// 派生类
class Rectangle: public Shape, public PaintCost
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};

int main(void)
{
   Rectangle Rect;
   int area;
 
   Rect.setWidth(5);
   Rect.setHeight(7);

   area = Rect.getArea();
   
   // 输出对象的面积
   cout << "Total area: " << Rect.getArea() << endl;

   // 输出总花费
   cout << "Total paint cost: $" << Rect.getCost(area) << endl;

   return 0;
}
Lorsque le code ci-dessus est compilé et exécuté, il produira les résultats suivants : 
Total area: 35
Total paint cost: 50

←
→