Menu

Types d'héritage en C ++

types inheritance c

Essayez Notre Instrument Pour Éliminer Les Problèmes

Explorez tous les types d'héritage en C ++ avec des exemples.

Dans notre didacticiel précédent, nous avons découvert l'héritage en C ++. Selon la manière dont la classe est dérivée ou le nombre de classes de base dont une classe hérite, nous avons les types d'héritage suivants:

  • Héritage unique
  • Héritage multiple
  • Héritage à plusieurs niveaux
  • Héritage hiérarchique
  • Héritage hybride

=> Voir ici pour explorer la liste complète des didacticiels C ++.

Types d

Ce que vous apprendrez:

Types d'héritage

Ci-dessous, une représentation picturale des différents types d'héritage.

types d

Nous verrons chaque type d'héritage avec des exemples dans les sections ci-dessous.

# 1) Héritage unique

Dans l'héritage simple, une classe dérive d'une seule classe de base. Cela signifie qu'il n'y a qu'une seule sous-classe dérivée d'une superclasse.

L'héritage unique est généralement déclaré comme suit:

class subclassname : accessspecifier superclassname { //class specific code; };

Héritage unique

Vous trouverez ci-dessous un exemple complet d'héritage unique.

#include #include using namespace std; class Animal { string name=''; public: int tail=1; int legs=4; }; class Dog : public Animal { public: void voiceAction() { cout<<'Barks!!!'; } }; int main() { Dog dog; cout<<'Dog has '<

Production:

Le chien a 4 pattes
Le chien a 1 queue
Le chien aboie!!!

Nous avons une classe Animal comme classe de base à partir de laquelle nous avons dérivé une sous-classe dog. Le chien de classe hérite de tous les membres de la classe Animal et peut être étendu pour inclure ses propres propriétés, comme indiqué dans la sortie.

L'héritage unique est la forme la plus simple d'héritage.

# 2) Héritage multiple

L'héritage multiple est illustré ci-dessous.

Héritage multiple

L'héritage multiple est un type d'héritage dans lequel une classe dérive de plusieurs classes. Comme le montre le diagramme ci-dessus, la classe C est une sous-classe qui a la classe A et la classe B comme parent.

Dans un scénario réel, un enfant hérite de son père et de sa mère. Cela peut être considéré comme un exemple d'héritage multiple.

Nous présentons le programme ci-dessous pour démontrer l'héritage multiple.

#include using namespace std; //multiple inheritance example class student_marks { protected: int rollNo, marks1, marks2; public: void get() { cout <> rollNo; cout <> marks1 >> marks2; } }; class cocurricular_marks { protected: int comarks; public: void getsm() { cout <> comarks; } }; //Result is a combination of subject_marks and cocurricular activities marks class Result : public student_marks, public cocurricular_marks { int total_marks, avg_marks; public: void display() { total_marks = (marks1 + marks2 + comarks); avg_marks = total_marks / 3; cout << ' Roll No: ' << rollNo << ' Total marks: ' << total_marks; cout << ' Average marks: ' << avg_marks; } }; int main() { Result res; res.get(); //read subject marks res.getsm(); //read cocurricular activities marks res.display(); //display the total marks and average marks }

Production:

Entrez le numéro de rouleau: 25
Entrez les deux notes les plus élevées: 40 50
Entrez la marque pour les activités co-curriculaires: 30

Rouleau No: 25
Total des notes: 120
Notes moyennes: 40

Dans l'exemple ci-dessus, nous avons trois classes, à savoir student_marks, cocurricular_marks et Result. La classe student_marks lit la note du sujet pour l'étudiant. La classe cocurricular_marks lit les notes de l’élève dans les activités parascolaires.

La classe Result calcule le total_marks de l'étudiant avec les notes moyennes.

Dans ce modèle, la classe Result est dérivée de student_marks et cocurricular_marks lorsque nous calculons le résultat à partir de la matière ainsi que les notes des activités parascolaires.

Cela présente de multiples héritages.

Problème de diamant

Le problème du diamant est représenté ci-dessous:

Problème de diamant

qu'est-ce que le test fonctionnel avec des exemples

Ici, nous avons une classe enfant héritant de deux classes Père et Mère. Ces deux classes, à leur tour, héritent de la classe Person.

Comme le montre la figure, la classe Enfant hérite les traits de la classe Personne deux fois, c'est-à-dire une fois de Père et la deuxième fois de Mère. Cela donne lieu à une ambiguïté car le compilateur ne parvient pas à comprendre la voie à suivre.

Puisque ce scénario se produit lorsque nous avons un héritage en forme de diamant, ce problème est appelé ' Le problème du diamant ».

Le problème Diamond implémenté en C ++ entraîne une erreur d'ambiguïté lors de la compilation. Nous pouvons résoudre ce problème en rendant la classe de base racine virtuelle. Nous en apprendrons plus sur le mot-clé «virtuel» dans notre prochain tutoriel sur le polymorphisme.

# 3) Héritage à plusieurs niveaux

L'héritage à plusieurs niveaux est représenté ci-dessous.

Héritage à plusieurs niveaux

Dans l'héritage à plusieurs niveaux, une classe est dérivée d'une autre classe dérivée. Cet héritage peut avoir autant de niveaux tant que notre implémentation ne va pas de travers. Dans le diagramme ci-dessus, la classe C est dérivée de la classe B.La classe B est à son tour dérivée de la classe A.

Voyons un exemple d'héritage à plusieurs niveaux.

#include #include using namespace std; class Animal { string name=''; public: int tail=1; int legs=4; }; class Dog : public Animal { public: void voiceAction() { cout<<'Barks!!!'; } }; class Puppy:public Dog{ public: void weeping() { cout<<'Weeps!!'; } }; int main() { Puppy puppy; cout<<'Puppy has '<

Production:

Le chiot a 4 pattes
Le chiot a 1 queue
Les aboiements de chiot !!! Chiot pleure !!

Ici, nous avons modifié l'exemple de l'héritage simple de sorte qu'il y ait une nouvelle classe Puppy qui hérite de la classe Dog qui à son tour hérite de la classe Animal. Nous voyons que la classe Puppy acquiert et utilise les propriétés et les méthodes des deux classes au-dessus.

# 4) Héritage hybride

L'héritage hybride est illustré ci-dessous.

Héritage hybride

L'héritage hybride est généralement une combinaison de plus d'un type d'héritage. Dans la représentation ci-dessus, nous avons l'héritage multiple (B, C et D) et l'héritage à plusieurs niveaux (A, B et D) pour obtenir un héritage hybride.

Voyons un exemple d'héritage hybride.

#include #include using namespace std; //Hybrid inheritance = multilevel + multilpe class student{ //First base Class int id; string name; public: void getstudent(){ cout <> id >> name; } }; class marks: public student{ //derived from student protected: int marks_math,marks_phy,marks_chem; public: void getmarks(){ cout <>marks_math>>marks_phy>>marks_chem; } }; class sports{ protected: int spmarks; public: void getsports(){ cout <> spmarks; } }; class result : public marks, public sports{//Derived class by multiple inheritance// int total_marks; float avg_marks; public : void display(){ total_marks=marks_math+marks_phy+marks_chem; avg_marks=total_marks/3.0; cout << 'Total marks =' << total_marks << endl; cout << 'Average marks =' << avg_marks << endl; cout << 'Average + Sports marks =' << avg_marks+spmarks; } }; int main(){ result res;//object// res.getstudent(); res.getmarks(); res.getsports(); res.display(); return 0; }

Production:

Entrez l'identifiant et le nom de l'élève 25 Ved
Entrez 3 points de sujet: 89 88 87
Entrez les notes sportives: 40
Total des points = 264
Notes moyennes = 88
Moyenne + notes sportives = 128

Ici, nous avons quatre classes à savoir étudiant, notes, sports et résultat. Les notes proviennent de la classe des élèves. La classe Result dérive de Marks and Sports lorsque nous calculons le résultat à partir des marques de sujet ainsi que des marques de sport.

La sortie est générée en créant un objet de la classe Result qui a acquis les propriétés des trois classes.

Notez que dans l'héritage hybride également, la mise en œuvre peut entraîner un «problème de diamant» qui peut être résolu en utilisant le mot-clé «virtuel» comme mentionné précédemment.

# 5) Héritage hiérarchique

héritage hiérarchique

Dans l'héritage hiérarchique, plus d'une classe hérite d'une seule classe de base, comme indiqué dans la représentation ci-dessus. Cela lui donne une structure hiérarchique.

Ci-dessous est l'exemple démontrant l'héritage hiérarchique.

#include using namespace std; //hierarchical inheritance example class Shape // shape class -> base class { public: int x,y; void get_data(int n,int m) { x= n; y = m; } }; class Rectangle : public Shape // inherit Shape class { public: int area_rect() { int area = x*y; return area; } }; class Triangle : public Shape // inherit Shape class { public: int triangle_area() { float area = 0.5*x*y; return area; } }; class Square : public Shape // inherit Shape class { public: int square_area() { float area = 4*x; return area; } }; int main() { Rectangle r; Triangle t; Square s; int length,breadth,base,height,side; //area of a Rectangle std::cout <>length>>breadth; r.get_data(length,breadth); int rect_area = r.area_rect(); std::cout << 'Area of the rectangle = ' <base>>height; t.get_data(base,height); float tri_area = t.triangle_area(); std::cout <<'Area of the triangle = ' << tri_area<side; s.get_data(side,side); int sq_area = s.square_area(); std::cout <<'Area of the square = ' << sq_area<

Production:

Entrez la longueur et la largeur d'un rectangle: 10 5
Aire du rectangle = 50
Entrez la base et la hauteur du triangle: 4 8
Aire du triangle = 16
Entrez la longueur d'un côté du carré: 5
Aire du carré = 20

L'exemple ci-dessus est un exemple classique de la classe Shape. Nous avons une classe de base Shape et trois classes, c'est-à-dire rectangle, triangle et carré en sont dérivés.

Nous avons une méthode pour lire les données dans la classe Shape tandis que chaque classe dérivée a sa propre méthode pour calculer l'aire. Dans la fonction principale, nous lisons les données pour chaque objet puis calculons la surface.

Conclusion

Comparé aux autres langages de programmation, le langage C ++ prend en charge tous les types d'héritage. En fait, nous pouvons dire que C ++ a un très bon support pour l'héritage. Nous pouvons modéliser les problèmes en temps réel plus efficacement en utilisant C ++.

Dans ce tutoriel, nous avons vu tous les types d'héritage pris en charge par C ++.

Lire aussi = >> Types d'héritage en Java

Dans notre prochain tutoriel, nous en apprendrons plus sur la fonction de polymorphisme de la POO.

=> Consultez la série complète de formations GRATUITES C ++ ici.

lecture recommandée

^