Meniu

Tipuri de moștenire în C ++

types inheritance c

Încercați Instrumentul Nostru Pentru Eliminarea Problemelor

Explorează toate tipurile de moștenire în C ++ cu exemple.

În tutorialul nostru anterior, am aflat despre moștenirea în C ++. În funcție de modul în care este derivată clasa sau de câte clase de bază moștenește o clasă, avem următoarele tipuri de moștenire:

  • Moștenirea unică
  • Moștenirea multiplă
  • Moștenirea pe mai multe niveluri
  • Moștenirea ierarhică
  • Moștenirea hibridă

=> Consultați aici pentru a explora lista completă de tutoriale C ++.

Tipuri de moștenire

Ce veți învăța:

Tipuri de moștenire

Mai jos este prezentată o reprezentare picturală a diferitelor tipuri de moștenire.

tipuri de moștenire

Vom vedea fiecare tip de moștenire cu exemple în secțiunile de mai jos.

# 1) Moștenirea unică

În moștenirea unică, o clasă derivă dintr-o singură clasă de bază. Aceasta înseamnă că există o singură subclasă care este derivată dintr-o superclasă.

Moștenirea unică este de obicei declarată după cum urmează:

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

Moștenire unică

Dat mai jos este un exemplu complet de moștenire unică.

#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 '<

Ieșire:

Câinele are 4 picioare
Câinele are 1 coadă
Cainele latra!!!

Avem o clasă Animal ca clasă de bază din care am derivat un câine de subclasă. Câinele de clasă moștenește toți membrii clasei Animal și poate fi extins pentru a include propriile sale proprietăți, după cum se vede din rezultat.

Moștenirea unică este cea mai simplă formă de moștenire.

# 2) Moștenirea multiplă

Moștenirea multiplă este reprezentată pictural mai jos.

Moștenirea multiplă

Moștenirea multiplă este un tip de moștenire în care o clasă derivă din mai multe clase. Așa cum se arată în diagrama de mai sus, clasa C este o subclasă care are clasa A și clasa B ca părinte.

Într-un scenariu din viața reală, un copil moștenește de la tată și mamă. Acest lucru poate fi considerat ca un exemplu de moștenire multiplă.

Vă prezentăm programul de mai jos pentru a demonstra moștenirea multiplă.

#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 }

Ieșire:

Introduceți numărul ruloului: 25
Introduceți cele două cele mai mari note: 40 50
Introduceți marca pentru activități curriculare: 30

Rola nr: 25
Total note: 120
Nota medie: 40

În exemplul de mai sus, avem trei clase și anume student_marks, cocurricular_marks și Result. Clasa student_marks citește nota subiectului pentru elev. Clasa cocurricular_marks citește notele elevului în activitățile co-curriculare.

Clasa Rezultat calculează total_markuri pentru elev împreună cu notele medii.

În acest model, clasa de rezultate este derivată din marcajele_student și marcajele_curriculare, pe măsură ce calculăm rezultatul din subiect, precum și notele activităților co-curriculare.

Aceasta prezintă mai multe moșteniri.

Problema diamantului

Diamond Problem este reprezentată pictural mai jos:

Problema diamantului

întrebări de interviu cu privire la metodologia agilă scrum

Aici avem o clasă de copii care moștenește două clase Tată și mamă. Aceste două clase, la rândul lor, moștenesc clasa Persoană.

După cum se arată în figură, clasa Copil moștenește trăsăturile clasei Persoană de două ori, adică o dată de la Tată și a doua oară de la Mama. Acest lucru dă naștere la ambiguitate, deoarece compilatorul nu înțelege ce cale să urmeze.

Deoarece acest scenariu apare atunci când avem o moștenire în formă de diamant, această problemă este numită „ Problema Diamantului ”.

Problema Diamond implementată în C ++ are ca rezultat o eroare de ambiguitate la compilare. Putem rezolva această problemă făcând clasa de bază rădăcină virtuală. Vom afla mai multe despre cuvântul cheie „virtual” în viitorul nostru tutorial despre polimorfism.

# 3) Moștenirea pe mai multe niveluri

Moștenirea pe mai multe niveluri este reprezentată mai jos.

Moștenirea pe mai multe niveluri

În moștenirea pe mai multe niveluri, o clasă este derivată dintr-o altă clasă derivată. Această moștenire poate avea la fel de multe niveluri, atâta timp cât implementarea noastră nu merge prea departe. În diagrama de mai sus, clasa C este derivată din clasa B. Clasa B este la rândul său derivată din clasa A.

Să vedem un exemplu de moștenire pe mai multe niveluri.

#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 '<

Ieșire:

Catelul are 4 picioare
Catelul are 1 coada
Catel latra !!! Catelul Plânge !!

Aici am modificat exemplul pentru moștenirea unică astfel încât să existe o nouă clasă Catelus care moștenește din clasa Câine care la rândul său moștenește din clasa Animal. Vedem că clasa Puppy dobândește și folosește proprietățile și metodele ambelor clase de deasupra ei.

# 4) Moștenirea hibridă

Moștenirea hibridă este descrisă mai jos.

Moștenirea hibridă

Moștenirea hibridă este de obicei o combinație de mai multe tipuri de moștenire. În reprezentarea de mai sus, avem moștenire multiplă (B, C și D) și moștenire pe mai multe niveluri (A, B și D) pentru a obține o moștenire hibridă.

Să vedem un exemplu de moștenire hibridă.

#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; }

Ieșire:

Introduceți codul de student și numele studentului 25 Ved
Introduceți 3 mărci de subiect: 89 88 87
Introduceți mărci sportive: 40
Total note = 264
Nota medie = 88
Media + notele sportive = 128

Aici avem patru clase, adică Student, Note, Sport și Rezultat. Mărcile sunt derivate din clasa elevilor. Clasa Rezultat derivă din notele și sporturile pe măsură ce calculăm rezultatul din notele subiectului, precum și din notele sportive.

Ieșirea este generată prin crearea unui obiect din clasa Rezultat care a dobândit proprietățile tuturor celor trei clase.

Rețineți că și în moștenirea hibridă, implementarea poate avea ca rezultat „Problema diamantului”, care poate fi rezolvată folosind cuvântul cheie „virtual” așa cum sa menționat anterior.

# 5) Moștenirea ierarhică

moștenirea ierarhică

În moștenirea ierarhică, mai mult de o clasă moștenește dintr-o singură clasă de bază, așa cum se arată în reprezentarea de mai sus. Acest lucru îi conferă o structură a unei ierarhii.

Mai jos este prezentat Exemplul care demonstrează moștenirea ierarhică.

#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<

Ieșire:

Introduceți lungimea și lățimea unui dreptunghi: 10 5
Suprafața dreptunghiului = 50
Introduceți baza și înălțimea triunghiului: 4 8
Aria triunghiului = 16
Introduceți lungimea unei laturi a pătratului: 5
Suprafața pătratului = 20

Exemplul de mai sus este un exemplu clasic de clasă Formă. Avem o clasă de bază Shape și trei clase adică dreptunghi, triunghi și pătrat sunt derivate din ea.

Avem o metodă de citire a datelor în clasa Shape, în timp ce fiecare clasă derivată are propria sa metodă de calcul al ariei. În funcția principală, citim date pentru fiecare obiect și apoi calculăm aria.

Concluzie

Comparativ cu celelalte limbaje de programare, limbajul C ++ acceptă toate tipurile de moștenire. De fapt, putem spune că C ++ are un suport foarte bun pentru moștenire. Putem modela problemele în timp real mai eficient folosind C ++.

În acest tutorial, am văzut toate tipurile de moștenire acceptate de C ++.

Citește și = >> Tipuri de moștenire în Java

În viitorul nostru tutorial, vom afla mai multe despre caracteristica polimorfismului OOP.

=> Verificați aici seria completă de antrenament GRATUIT C ++.

Lectură recomandată

^