types inheritance c
Esplora tutti i tipi di ereditarietà in C ++ con esempi.
Nel nostro precedente tutorial, abbiamo imparato a conoscere l'ereditarietà in C ++. A seconda del modo in cui viene derivata la classe o di quante classi base eredita da una classe, abbiamo i seguenti tipi di ereditarietà:
- Ereditarietà singola
- Ereditarietà multipla
- Ereditarietà multilivello
- Ereditarietà gerarchica
- Eredità ibrida
=> Vedi qui per esplorare l'elenco completo dei tutorial C ++.
Cosa imparerai:
Tipi di ereditarietà
Di seguito è riportata una rappresentazione pittorica dei vari tipi di eredità.
Vedremo ogni tipo di ereditarietà con esempi nelle sezioni seguenti.
# 1) Ereditarietà singola
Nell'ereditarietà singola, una classe deriva da una sola classe base. Ciò significa che esiste solo una sottoclasse derivata da una superclasse.
L'ereditarietà singola viene solitamente dichiarata come segue:
class subclassname : accessspecifier superclassname { //class specific code; };
Di seguito è riportato un esempio completo di ereditarietà singola.
#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 '< Produzione:
Il cane ha 4 zampe
Il cane ha 1 coda
Il cane abbaia!!!
Abbiamo una classe Animal come classe base da cui abbiamo derivato una sottoclasse cane. La classe dog eredita tutti i membri della classe Animal e può essere estesa per includere le proprie proprietà, come si vede dall'output.
L'ereditarietà singola è la forma più semplice di eredità.
# 2) Ereditarietà multipla
L'ereditarietà multipla è rappresentata graficamente di seguito.

L'ereditarietà multipla è un tipo di ereditarietà in cui una classe deriva da più di una classe. Come mostrato nel diagramma sopra, la classe C è una sottoclasse che ha la classe A e la classe B come genitore.
In uno scenario di vita reale, un bambino eredita dal padre e dalla madre. Questo può essere considerato un esempio di eredità multipla.
Presentiamo il programma seguente per dimostrare l'ereditarietà multipla.
#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 }
Produzione:
Immettere il numero del rotolo: 25
Inserisci i due punteggi più alti: 40 50
Inserisci il punteggio per Attività CoCurricular: 30
Rotolo n .: 25
Voti totali: 120
Voto medio: 40
Nell'esempio sopra, abbiamo tre classi, ovvero student_marks, cocurricular_marks e Result. La classe student_marks legge il voto di soggetto per lo studente. La classe cocurricular_marks legge i voti dello studente nelle attività co-curriculari.
La classe Result calcola i total_marks per lo studente insieme ai voti medi.
In questo modello, la classe Result è derivata da student_marks e cocurricular_marks mentre calcoliamo il risultato dalla materia così come i punteggi delle attività co-curriculari.
Questo mostra più eredità.
Problema con i diamanti
Diamond Problem è rappresentato graficamente di seguito:

cos'è il beta test nel test del software
Qui, abbiamo una classe figlio che eredita due classi Padre e Madre. Queste due classi, a loro volta, ereditano la classe Persona.
Come mostrato nella figura, la classe Child eredita i tratti della classe Persona due volte, ovvero una volta da Padre e la seconda volta da Madre. Ciò genera ambiguità poiché il compilatore non riesce a capire in che direzione andare.
Poiché questo scenario si verifica quando abbiamo un'eredità a forma di diamante, questo problema è notoriamente chiamato ' Il problema del diamante '.
Il problema Diamond implementato in C ++ genera un errore di ambiguità durante la compilazione. Possiamo risolvere questo problema rendendo virtuale la classe base radice. Impareremo di più sulla parola chiave 'virtuale' nel nostro prossimo tutorial sul polimorfismo.
# 3) Ereditarietà multilivello
L'ereditarietà multilivello è rappresentata di seguito.

Nell'ereditarietà multilivello, una classe è derivata da un'altra classe derivata. Questa eredità può avere tanti livelli purché la nostra implementazione non sia ribelle. Nel diagramma sopra, la classe C è derivata dalla classe B. La classe B è a sua volta derivata dalla classe A.
Vediamo un esempio di ereditarietà multilivello.
#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 '< Produzione:
Il cucciolo ha 4 zampe
Il cucciolo ha 1 coda
Puppy Barks !!! Puppy Weeps !!
Qui abbiamo modificato l'esempio per l'ereditarietà singola in modo che ci sia una nuova classe Puppy che eredita dalla classe Dog che a sua volta eredita dalla classe Animal. Vediamo che la classe Puppy acquisisce e utilizza le proprietà ei metodi di entrambe le classi sopra di essa.
# 4) Ereditarietà ibrida
L'ereditarietà ibrida è illustrata di seguito.

L'ereditarietà ibrida è solitamente una combinazione di più di un tipo di eredità. Nella rappresentazione sopra, abbiamo ereditarietà multipla (B, C e D) e eredità multilivello (A, B e D) per ottenere un'eredità ibrida.
Vediamo un esempio di ereditarietà ibrida.
#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; }
Produzione:
Immettere l'ID e il nome dello studente 25 Ved
Immettere 3 segni di soggetto: 89 88 87
Inserisci voti sportivi: 40
Punteggio totale = 264
Voto medio = 88
Media + voti sportivi = 128
Qui abbiamo quattro classi, ovvero Studente, Voti, Sport e Risultato. I voti derivano dalla classe dello studente. Il risultato della classe deriva da Marks and Sports poiché calcoliamo il risultato dai punteggi del soggetto e dai voti sportivi.
L'output viene generato creando un oggetto di classe Result che ha acquisito le proprietà di tutte e tre le classi.
Si noti che anche nell'ereditarietà ibrida, l'implementazione può dare come risultato un 'problema diamante' che può essere risolto utilizzando la parola chiave 'virtuale' come menzionato in precedenza.
# 5) Ereditarietà gerarchica

Nell'ereditarietà gerarchica, più di una classe eredita da una singola classe di base come mostrato nella rappresentazione sopra. Questo gli conferisce una struttura gerarchica.
Di seguito è riportato l'esempio che dimostra l'ereditarietà gerarchica.
#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< Produzione:
Immettere la lunghezza e la larghezza di un rettangolo: 10 5
Area del rettangolo = 50
Immettere la base e l'altezza del triangolo: 4 8
Area del triangolo = 16
Immettere la lunghezza di un lato del quadrato: 5
Area del quadrato = 20
L'esempio sopra è un classico esempio della classe Shape. Abbiamo una forma di classe base e da essa derivano tre classi, ovvero rettangolo, triangolo e quadrato.
Abbiamo un metodo per leggere i dati nella classe Shape mentre ogni classe derivata ha il proprio metodo per calcolare l'area. Nella funzione principale, leggiamo i dati per ogni oggetto e quindi calcoliamo l'area.
Conclusione
Rispetto agli altri linguaggi di programmazione, il linguaggio C ++ supporta tutti i tipi di ereditarietà. In effetti, possiamo dire che il C ++ ha un ottimo supporto per l'ereditarietà. Possiamo modellare i problemi in tempo reale in modo più efficace utilizzando C ++.
In questo tutorial abbiamo visto tutti i tipi di ereditarietà supportati da C ++.
Leggi anche = >> Tipi di ereditarietà in Java
Nel nostro prossimo tutorial, impareremo di più sulla caratteristica del polimorfismo di OOP.
=> Controlla qui la serie completa di formazione GRATUITA C ++.
Lettura consigliata
- Ereditarietà in C ++
- Tipi di dati C ++
- Tipi di rischi nei progetti software
- Tipi di dati Python
- Miglior serie di tutorial GRATUITI per C #: la guida definitiva a C # per principianti
- Tipi di cicli di shell Unix: Do While Loop, For Loop, Until Loop in Unix
- Diversi tipi di matcher forniti da Mockito
- 7 tipi di errori software che ogni tester dovrebbe conoscere