Héritage C ++

L'héritage est une caractéristique très importante de la programmation orientée objet. Il permet au programmeur de dériver une classe d'une classe existante. Ceci est très utile surtout dans un grand projet complexe car il permet au programmeur de réutiliser le code.

Dans cet article, nous allons discuter du concept d'héritage dans la programmation C ++. Nous expliquerons le concept de la fonction d'ami en C ++ avec des exemples de travail.

Pourquoi l'héritage?

L'héritage permet de créer une nouvelle classe ou une classe dérivée d'une autre classe ou d'une classe de base. La classe dérivée ou la classe d'enfants aura toutes les fonctionnalités de la classe des parents ou de la classe de base. Nous pouvons réutiliser le code à l'aide de l'héritage.

Type d'hérédité

Il existe différents types d'héritage:

1. Héritage simple / simple
2. Héritage hiérarchique
3. Héritage à plusieurs niveaux
4. Héritage multiple

Dans cet article, nous allons ne considérer que l'héritage simple / unique.

Exemple 1:

Maintenant, examinons un exemple de programme pour comprendre le concept d'hérédité en C++. Nous avons défini une classe de base puis en avons dérivé une autre classe. Par conséquent, la classe dérivée aura les fonctionnalités (membres et fonctions) de la classe de base.

#inclure
Utilisation de Namespace Std;
classe Base_class

public:
int i;
vide affiche ()

couter << "Display of Base Class " << i << endl;

;
Class Derive_class: Public Base_class

public:
void show ()

couter << "Show of Derived Class" << endl;

;
int main()

Derived_class dc;
dc.i = 100;
dc.afficher();
dc.montrer();
retour 0;

Exemple 2:

Ceci est un autre exemple d'hérédité en C++. Dans cet exemple, nous allons voir comment les constructeurs sont appelés lorsqu'un objet de classe dérivé est créé.

Comme vous pouvez le voir ci-dessous, nous avons défini deux constructeurs de classe de base et trois constructeurs de classe dérivés. Vous pouvez clairement remarquer à partir de la sortie ci-dessous que le constructeur de classe de base est appelé en premier avant que le constructeur de classe dérivé ne soit appelé.

#inclure
Utilisation de Namespace Std;
classe Base_class

public:
Base_class ()

couter << "Base_Class - No Parameters" << endl;

Base_class (int x)

couter << "Base_Class - Parameters : " << x << endl;

;
Class Derive_class: Public Base_class

public:
Classe dérivée()

couter << "Derived_Class - No Parameters" << endl;

Derive_class (int y)

couter << "Derived_Class - Parameters : " << y << endl;

Derive_class (int x, int y): base_class (x)

couter << "Param of Derived_Class : " << y << endl;

;
int main()

Derived_class d (7,19);

Exemple 3:

Dans cet exemple, nous allons voir comment des objets de classe dérivés peuvent être utilisés.

Comme vous pouvez le voir, il y a deux classes définies: rectangle_class et cube_class. Le rectangle_class est la classe de base à partir de laquelle la classe dérivée, i.e., Cube_class est dérivé. Par conséquent, nous héritons des fonctionnalités du rectangle_class à cube_class.

Vous pouvez également remarquer que nous héritons du cube_class avec le contrôle d'accès public. Cela signifie que la classe dérivée peut accéder à tous les membres non privés de la classe de base.

Nous avons déclaré un objet de la classe dérivée, puis appelons les méthodes de la classe de base, je.e., setLength () et setBreadth ().

#inclure
Utilisation de Namespace Std;
classe rectangle_class

privé:
longueur int;
dans la largeur;
public:
Rectangle_class ();
Rectangle_class (int l, int b);
Rectangle_class (rectangle_class & r);
int getLength ()

longueur de retour;

int getBreadth ()

retour de la largeur;

void setLength (int l);
void setBreadth (int b);
Int Area ();
;
classe Cube_class: public rectangle_class

privé:
Hauteur int;
public:
Cube_class (int h)

hauteur = h;

int getheight ()

hauteur de retour;

void Setheight (int h)

hauteur = h;

int volume ()

return getLength () * getBreadth () * hauteur;

;
Rectangle_class :: rectangle_class ()

longueur = 1;
largeur = 1;

Rectangle_class :: rectangle_class (int l, int b)

longueur = l;
largeur = b;

Rectangle_class :: rectangle_class (rectangle_class & r)

longueur = r.longueur;
Largeur = R.largeur;

void rectangle_class :: setLength (int l)

longueur = l;

void rectangle_class :: setBreadth (int b)

largeur = b;

int rectangle_class :: area ()

Longueur de retour * largeur;

int main()

Cube_class c (8);
c.setLength (12);
c.SetBreadth (9);
couter<<"Volume is "<

Conclusion:

Dans cet article, j'ai expliqué le concept d'hérédité en C++. Le C ++ prend en charge différents types d'héritage, y compris «l'héritage multiple» (i.e., Héritage des fonctionnalités de la classe de base multiple ou de la classe parent). Cependant, pour le rendre plus simple, je n'ai considéré que l'héritage unique ici. J'ai montré trois exemples de travail pour expliquer comment nous pouvons utiliser l'héritage dans la programmation C ++ et réutiliser le code. De plus, c'est une caractéristique très utile de C++.