Phenquestions
Dans cet article, nous allons discuter du concept d'héritage dans la programmation C++. Nous expliquerons le concept de la fonction friend 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 à partir d'une autre classe ou classe de base. La classe dérivée ou la classe enfant aura toutes les fonctionnalités de la classe parent ou de la classe de base. Nous pouvons réutiliser le code à l'aide de l'héritage.
Type d'héritage
Il existe différents types d'héritage :
- Héritage simple/unique
- Héritage hiérarchique
- Héritage à plusieurs niveaux
- Héritage multiple
Dans cet article, nous allons considérer uniquement l'héritage simple/simple.
Exemple 1:
Maintenant, regardons un exemple de programme pour comprendre le concept d'héritage 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 caractéristiques (membres et fonctions) de la classe de base.
#inclureen utilisant l'espace de noms std ;
classe Base_Class
Publique:
int je;
affichage vide()
cout << "Display of Base Class " << i << endl;
;
classe Derived_Class:public Base_Class
Publique:
spectacle nul ()
cout << "Show of Derived Class" << endl;
;
int main()
Derived_Class dc;
courant continu.je = 100 ;
courant continu.affichage();
courant continu.spectacle();
renvoie 0 ;
Exemple 2 :
Ceci est un autre exemple d'héritage en C++. Dans cet exemple, nous allons voir comment les constructeurs sont appelés lorsqu'un objet de classe dérivée 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ée. Vous pouvez clairement remarquer à partir de la sortie ci-dessous que le constructeur de la classe de base est appelé en premier avant que le constructeur de la classe dérivée ne soit appelé.
#inclure#inclure
en utilisant l'espace de noms std ;
classe Base_Class
Publique:
Base_Class()
cout << "Base_Class - No Parameters" << endl;
Base_Class(int x)
cout << "Base_Class - Parameters : " << x << endl;
;
classe Derived_Class:public Base_Class
Publique:
Classe dérivée()
cout << "Derived_Class - No Parameters" << endl;
Derived_Class(int y)
cout << "Derived_Class - Parameters : " << y << endl;
Derived_Class(int x,int y):Base_Class(x)
cout << "Param of Derived_Class : " << y << endl;
;
int main()
Classe_dérivée d(7,19);
Exemple 3 :
Dans cet exemple, nous allons voir comment les objets de classe dérivée 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 de Rectangle_Class à Cube_Class.
De plus, vous pouvez remarquer que nous héritons de la 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, i.e., setLength() et setBreadth().
#inclureen utilisant l'espace de noms std ;
classe Rectangle_Class
privé:
longueur entière;
largeur int;
Publique:
Classe_Rectangle();
Rectangle_Class(int l,int b);
Classe_Rectangle(Classe_Rectangle &r);
int getLength()
longueur de retour ;
int getBreadth()
largeur de retour;
void setLength(int l);
void setBreadth(int b);
int zone();
;
classe Cube_Class:public Rectangle_Class
privé:
int hauteur;
Publique:
Cube_Class(int h)
hauteur=h;
int obtenirHauteur()
hauteur de retour;
void setHeight(int h)
hauteur=h;
int volume()
return getLength()*getBreadth()*height ;
;
Classe_Rectangle::Classe_Rectangle()
longueur=1;
largeur=1;
Rectangle_Class::Rectangle_Class(int l,int b)
longueur=l;
largeur=b;
Classe_Rectangle::Classe_Rectangle(Classe_Rectangle &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()
renvoie longueur*largeur ;
int main()
Cube_Classe c(8) ;
c.setLength(12);
c.setBreadth(9) ;
cout<<"Volume is "<
Conclusion:
Dans cet article, j'ai expliqué le concept d'héritage en C++. Le C++ prend en charge différents types d'héritage, y compris « l'héritage multiple » (i.e., hériter des fonctionnalités de plusieurs classes de base ou classes parentes). Cependant, pour simplifier, je n'ai considéré ici que l'héritage unique. 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 fonctionnalité très utile de C++.
