In questo articolo imparerai a conoscere diversi modelli di ereditarietà nella programmazione C ++: ereditarietà multipla, multilivello e gerarchica con esempi.
L'ereditarietà è una delle caratteristiche principali di un linguaggio di programmazione orientato agli oggetti. Consente agli sviluppatori di software di derivare una nuova classe dalla classe esistente. La classe derivata eredita le caratteristiche della classe base (classe esistente).
Esistono vari modelli di ereditarietà nella programmazione C ++.
Ereditarietà multilivello C ++
Nella programmazione C ++, non solo è possibile derivare una classe dalla classe base, ma è anche possibile derivare una classe dalla classe derivata. Questa forma di eredità è nota come eredità multilivello.
classe A (… ); classe B: pubblico A (…); classe C: pubblico B (………);
Qui, la classe B è derivata dalla classe base A e la classe C è derivata dalla classe derivata B.
Esempio 1: ereditarietà multilivello C ++
#include using namespace std; class A ( public: void display() ( cout<<"Base class content."; ) ); class B : public A ( ); class C : public B ( ); int main() ( C obj; obj.display(); return 0; )
Produzione
Contenuto della classe di base.
In questo programma, la classe C deriva dalla classe B (che deriva dalla classe base A).
L'oggetto obj della classe C è definito nella main()funzione.
Quando la display()funzione viene chiamata, display()nella classe A viene eseguita. È perché non esiste una display()funzione nella classe C e nella classe B.
Il compilatore cerca prima la display()funzione nella classe C. Poiché la funzione non esiste lì, cerca la funzione nella classe B (poiché C è derivato da B).
La funzione inoltre non esiste nella classe B, quindi il compilatore la cerca nella classe A (poiché B deriva da A).
Se la display()funzione esiste in C, il compilatore sovrascrive la display()classe A (a causa dell'override della funzione membro).
Ereditarietà multipla C ++
Nella programmazione C ++, una classe può essere derivata da più genitori. Ad esempio: una classe Bat è derivata dalle classi base Mammal e WingedAnimal. Ha senso perché il pipistrello è un mammifero oltre che un animale alato.
Esempio 2: ereditarietà multipla nella programmazione C ++
#include using namespace std; class Mammal ( public: Mammal() ( cout << "Mammals can give direct birth." << endl; ) ); class WingedAnimal ( public: WingedAnimal() ( cout << "Winged animal can flap." << endl; ) ); class Bat: public Mammal, public WingedAnimal ( ); int main() ( Bat b1; return 0; )
Produzione
I mammiferi possono partorire direttamente. L'animale alato può sbattere.
Ambiguità nell'ereditarietà multipla
Il problema più evidente con l'ereditarietà multipla si verifica durante l'override della funzione.
Supponiamo che due classi base abbiano una stessa funzione che non viene sovrascritta nella classe derivata.
Se provi a chiamare la funzione utilizzando l'oggetto della classe derivata, il compilatore mostra l'errore. È perché il compilatore non sa quale funzione chiamare. Per esempio,
class base1 ( public: void someFunction( ) (… .… … . ) ); class base2 ( void someFunction( ) (… .… … . ) ); class derived : public base1, public base2 ( ); int main() ( derived obj; obj.someFunction() // Error! )
Questo problema può essere risolto utilizzando la funzione di risoluzione dell'ambito per specificare quale funzione classificare base1 o base2
int main () (obj.base1 :: someFunction (); // La funzione della classe base1 è chiamata obj.base2 :: someFunction (); // La funzione della classe base2 è chiamata.)
Ereditarietà gerarchica C ++
Se più di una classe viene ereditata dalla classe di base, è nota come eredità gerarchica. Nell'ereditarietà gerarchica, tutte le funzionalità comuni nelle classi figlie sono incluse nella classe base.
Ad esempio: Fisica, Chimica, Biologia derivano dalla classe di Scienze.
Sintassi dell'ereditarietà gerarchica
class base_class (…) class first_derived_class: public base_class (…) class second_derived_class: public base_class (…) class third_derived_class: public base_class (…)
