Menú

Tipus d’herència en C ++

types inheritance c

Proveu El Nostre Instrument Per Eliminar Problemes

Exploreu tots els tipus d’herència en C ++ amb exemples.

Al nostre tutorial anterior, vam aprendre sobre l’herència en C ++. Depenent de la manera com es derivi la classe o de quantes classes base hereta una classe, tenim els següents tipus d'herència:

  • Herència única
  • Herència múltiple
  • Herència multinivell
  • Herència jeràrquica
  • Herència híbrida

=> Vegeu aquí per explorar la llista completa de tutorials de C ++.

Tipus d’herència

Què aprendreu:

Tipus d’herència

A continuació es mostra una representació pictòrica dels diversos tipus d’herència.

tipus d’herència

Veurem cada tipus d’herència amb exemples a les seccions següents.

# 1) Herència única

En una sola herència, una classe només deriva d’una classe base. Això significa que només hi ha una subclasse que es deriva d'una superclasse.

L’herència única es declara normalment de la següent manera:

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

Herència única

A continuació es mostra un exemple complet d’herència única.

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

Sortida:

El gos té 4 potes
El gos té 1 cua
Gossos borda !!!

Tenim una classe Animal com a classe base de la qual hem derivat un gos de subclasse. El gos de classe hereta tots els membres de la classe Animal i es pot ampliar per incloure les seves pròpies propietats, tal com es veu a la sortida.

L’herència única és la forma d’herència més simple.

# 2) Herència múltiple

A continuació es representa pictòricament l’herència.

Herència múltiple

L'herència múltiple és un tipus d'herència en què una classe deriva de més d'una classe. Com es mostra al diagrama anterior, la classe C és una subclasse que té la classe A i la classe B com a pare.

En un escenari de la vida real, un nen hereta del seu pare i de la seva mare. Això es pot considerar com un exemple d’herència múltiple.

Presentem el programa següent per demostrar l’herència múltiple.

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

Sortida:

Introduïu el número de rotllo: 25
Introduïu les dues notes més altes: 40 50
Introduïu la marca d'Activitats CoCurriculars: 30

Rotllo núm: 25
Total de notes: 120
Mitjana de notes: 40

A l'exemple anterior, tenim tres classes, és a dir, marques_estudiant, marques_curriculars i Resultat. La classe student_marks llegeix la nota de l'assignatura de l'estudiant. La classe cocurricular_marks llegeix les notes de l’alumne en activitats co-curriculars.

La classe Resultat calcula el total_marks de l'estudiant juntament amb la nota mitjana.

En aquest model, la classe Resultat es deriva de marques_student i marques_curriculars a mesura que calculem Resultat de l'assignatura, així com les notes d'activitats co-curriculars.

Això exhibeix múltiples herències.

Problema del diamant

Diamond Problem es representa pictòricament a continuació:

Problema del diamant

amb què obrir fitxers swf

Aquí tenim una classe infantil que hereta dues classes Pare i Mare. Aquestes dues classes, al seu torn, hereten la classe Persona.

Com es mostra a la figura, la classe Child hereta els trets de la classe Person dues vegades, és a dir, una vegada del pare i la segona vegada de la mare. Això dóna lloc a ambigüitats ja que el compilador no entén quin camí cal seguir.

Atès que aquest escenari sorgeix quan tenim una herència en forma de diamant, aquest problema es diu famosament ' El problema del diamant '.

El problema Diamond implementat a C ++ resulta en un error d'ambigüitat en la compilació. Podem resoldre aquest problema fent que la classe base arrel sigui virtual. Aprendrem més sobre la paraula clau “virtual” al proper tutorial sobre polimorfisme.

# 3) Herència multinivell

A continuació es representa l’herència multinivell.

Herència multinivell

En l'herència multinivell, una classe es deriva d'una altra classe derivada. Aquesta herència pot tenir tants nivells sempre que la nostra implementació no vagi cap endavant. En el diagrama anterior, la classe C es deriva de la classe B. La classe B es deriva al seu torn de la classe A.

Vegem un exemple d’herència multinivell.

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

Sortida:

Cadell té 4 potes
El cadell té 1 cua
Cadell borda !!! Puppy Plora !!

Aquí hem modificat l'exemple de l'herència única de manera que hi ha una nova classe Puppy que hereta de la classe Dog que al seu torn hereta de la classe Animal. Veiem que la classe Puppy adquireix i utilitza les propietats i mètodes de les dues classes que hi ha a sobre.

# 4) Herència híbrida

A continuació es representa l’herència híbrida.

Herència híbrida

L’herència híbrida sol ser una combinació de més d’un tipus d’herència. A la representació anterior, tenim una herència múltiple (B, C i D) i una herència multinivell (A, B i D) per obtenir una herència híbrida.

Vegem un exemple d’herència híbrida.

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

Sortida:

Introduïu la identificació i el nom de l'estudiant 25 Ved
Introduïu 3 marques d'assumpte: 89 88 87
Introduïu marques esportives: 40
Puntuacions totals = 264
Mitjana de notes = 88
Mitjana + marques esportives = 128

Aquí tenim quatre classes, és a dir, Estudiant, Marques, Esports i Resultat. Les notes es deriven de la classe dels estudiants. La classe Resultat deriva de Marques i esports a mesura que calculem el resultat tant de les assignatures com de les marques esportives.

La sortida es genera creant un objecte de classe Resultat que ha adquirit les propietats de les tres classes.

Tingueu en compte que també en herència híbrida, la implementació pot donar lloc a 'Problema de diamant' que es pot resoldre mitjançant la paraula clau 'virtual' tal com s'ha esmentat anteriorment.

# 5) Herència jeràrquica

herència jeràrquica

En herència jeràrquica, més d'una classe hereta d'una sola classe base, tal com es mostra a la representació anterior. Això li dóna una estructura de jerarquia.

A continuació es mostra l'exemple que demostra l'herència jeràrquica.

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

Sortida:

Introduïu la longitud i l'amplada d'un rectangle: 10 5
Àrea del rectangle = 50
Introduïu la base i l'alçada del triangle: 4 8
Àrea del triangle = 16
Introduïu la longitud d’un costat del quadrat: 5
Àrea del quadrat = 20

L'exemple anterior és un exemple clàssic de classe Forma. Tenim una classe base Shape i se’n deriven tres classes, és a dir, rectangle, triangle i quadrat.

Tenim un mètode per llegir dades a la classe Shape, mentre que cada classe derivada té el seu propi mètode per calcular l'àrea. A la funció principal, llegim les dades de cada objecte i després calculem l'àrea.

Conclusió

En comparació amb els altres llenguatges de programació, el llenguatge C ++ admet tot tipus d’herència. De fet, podem dir que C ++ té molt bon suport per a l’herència. Podem modelar problemes en temps real de manera més eficaç mitjançant C ++.

En aquest tutorial, hem vist tots els tipus d’herència suportats per C ++.

Llegiu també = >> Tipus d’herència a Java

Al nostre proper tutorial, aprendrem més sobre la característica de polimorfisme de l'OOP.

=> Consulteu aquí la sèrie de formació GRATU FREETA de C ++.

Lectura recomanada

^