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 pratiques.
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:
Examinons maintenant 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.
#comprendreen utilisant l'espace de noms std;
classe Base_Class
{
Publique:
entierje;
annuleraffichage()
{
cout<< 'Affichage de la classe de base' <<je<<fin;
}
};
classe Derived_Class:classe_base publique
{
Publique:
annulerspectacle()
{
cout<< 'Affichage de la classe dérivée' <<fin;
}
};
entierprincipale()
{
Derived_Class dc;
cc.je = 100;
cc.affichage();
cc.spectacle();
revenir 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 le constructeur de la classe dérivée.
#comprendreen utilisant l'espace de noms std;
classe Base_Class
{
Publique:
Classe_base()
{
cout<< 'Base_Class - Aucun paramètre' <<fin;
}
Classe_base(entierX)
{
cout<< 'Classe_Base - Paramètres : ' <<X<<fin;
}
};
classe Derived_Class:classe_base publique
{
Publique:
Classe dérivée()
{
cout<< 'Derived_Class - Aucun paramètre' <<fin;
}
Classe dérivée(entieret)
{
cout<< 'Classe_dérivée - Paramètres : ' <<et<<fin;
}
Classe dérivée(entierX,entieret):Classe_base(X)
{
cout<< 'Param de Derived_Class : ' <<et<<fin;
}
};
entierprincipale()
{
Dérivée_Classe 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. La Rectangle_Class est la classe de base à partir de laquelle la classe dérivée, c'est-à-dire Cube_Class est dérivée. 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, c'est-à-dire setLength() et setBreadth().
#comprendreen utilisant l'espace de noms std;
classe Rectangle_Class
{
privé:
entierlongueur;
entierlargeur;
Publique:
Rectangle_Class();
Rectangle_Class(entierl,entierb);
Rectangle_Class(Rectangle_Class&r);
entierobtenirLongueur()
{
revenirlongueur;
}
entierobtenirBreadth()
{
revenirlargeur;
}
annulersetLength(entierl);
annulersetBreadth(entierb);
entierRégion();
};
classe Cube_Class:public Rectangle_Class
{
privé:
entierla taille;
Publique:
Classe_cube(entierh)
{
la taille=h;
}
entierobtenirHauteur()
{
revenirla taille;
}
annulersetHeight(entierh)
{
la taille=h;
}
entierle volume()
{
revenirobtenirLongueur()*obtenirBreadth()*la taille;
}
};
Rectangle_Class::Rectangle_Class()
{
longueur=1;
largeur=1;
}
Rectangle_Class::Rectangle_Class(entierl,entierb)
{
longueur=l;
largeur=b;
}
Rectangle_Class::Rectangle_Class(Rectangle_Class&r)
{
longueur=r.longueur;
largeur=r.largeur;
}
annulerRectangle_Class::setLength(entierl)
{
longueur=l;
}
annulerRectangle_Class::setBreadth(entierb)
{
largeur=b;
}
entierRectangle_Class::Région()
{
revenirlongueur*largeur;
}
entierprincipale()
{
Cube_Classe c(8);
c.setLength(12);
c.setBreadth(9);
cout<<'Le volume est'<<c.le volume()<<fin;
}
Conclusion:
Dans cet article, j'ai expliqué le concept d'héritage dans C++ . Le C++ prend en charge différents types d'héritage, y compris l'héritage multiple (c'est-à-dire l'héritage de 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++.