Grafico comparativo
| Base per il confronto | Single Inheritance | Eredità multipla |
|---|---|---|
| Di base | La classe derivata eredita una singola classe base. | La classe derivata eredita due o più di due classi base. |
| Implementazione | Classe derived_class: classe base access_specifier | Classe derivata _class: access_specifier base_class1, access_specifier base_class2, .... |
| Accesso | Accesso classe derivato alle caratteristiche della singola classe base | Accesso classe derivato alle funzionalità combinate delle classi base ereditate |
| Visibilità | Pubblico, Privato, Protetto | Pubblico, Privato, Protetto |
| Tempo di esecuzione | Richiede una piccola quantità di tempo di esecuzione in testa | Richiede un sovraccarico di runtime aggiuntivo rispetto all'ereditarietà singola |
Definizione di ereditarietà singola
Nell'ereditarietà singola, esiste una singola classe base e una singola classe derivata. La classe derivata eredita la classe base in modo pubblico, protetto e privato. È possibile accedere ai membri della classe base in base alla classe derivata in base allo specificatore di accesso specificato durante l'ereditarietà della classe base.
Facciamo un esempio di vita reale che abbiamo due classi, una "classe di conto" e una "classe di account di risparmio". Qui "salvare la classe di account" può ereditare la funzione di "classe account", quindi la classe "classe account" diventerà classe base / super / genitore per il salvataggio della classe di account e "la classe di account di salvataggio" sarà una classe derivata.
Qui gli attributi di "account class" sono acc_no (privato) e balance (pubblico), e le funzioni membro sono initialize (), get_accno () che sono public. Ora, "la classe di account" viene ereditata come "salvando la classe di account" pubblicamente, quindi è possibile accedere direttamente a tutti i membri pubblici della "classe di account" "salvando la classe di account". Può accedere al membro privato della "classe account" tramite le funzioni pubbliche membro di "classe account" ma non può accedervi direttamente.
Attuazione dell'eredità singola:
# include usando lo spazio dei nomi std; class Account {int acc_no, ; pubblico: bilancio flottante; void initialize (int x, int y) {acc_no = x; balance = y; } int get_accno. () {return acc_no; }}; class Saving_acc: public Account {float intrest_rate; public: // costruttore di Saving_acc class Saving_acc (int c) {interest_rate = c; } void display () {cout < Definizione di ereditarietà multipla
L'ereditarietà multipla consente alla classe derivata di ereditare funzioni combinate di più di una classe base, ovvero abbiamo una singola classe derivata e più classi base. Ogni classe base deve essere ereditata menzionando l'identificatore di accesso separato per ognuno di essi. Una classe derivata può accedere ai membri delle classi di base in base allo specificatore di accesso con cui viene ereditata la classe di base.
Consente di rendere più facile con l'esempio che abbiamo tre classi cioè bici, auto e veicolo. Ora, "Vehicle" può ereditare le caratteristiche di "Bike" e "Car". Quindi, "Vehicle" diventa classe derivata e "Bike" e "Car" diventano la classe base. Ora "Bike" e "Car" sono ereditate pubblicamente da "Vehicle" e possono accedere a tutti i membri pubblici di "Bike" e "Car", ma poiché abbiamo un'entità Model_no protetta in "Car", quindi privata a Car ma può essere accesso da "Veicolo".
Attuazione dell'ereditarietà multipla:
# include l'uso di namespace std; class Bike {int engine_cost; ; pubblico: void set_engine_cost (int x) {engine_cost = x; }}; class Car {protected: int Model_no; pubblico: void set_Model_no (int p) {Model_no = p; }}; class Vehical: public Bike, public car {int no_of_wheels public: vehical (int w) {no_of_wheels = w; cout << "no di ruote" < Differenze chiave tra ereditarietà singola e multipla
- L'ereditarietà singola è una classe derivata che ha una singola classe di base mentre, nell'eredità multipla, ha due o più di due classi di base, ma una singola classe derivata.
- L'ereditarietà multipla è abbastanza confusa poiché qui una singola classe derivata eredita due o più classi base. Se le classi base hanno un attributo o una funzione con lo stesso nome, allora per la classe derivata diventa difficile identificare quale attributo o funzione della classe base deve derivare.
- I problemi generali sono minori in caso di ereditarietà singola. Ma in caso di ereditarietà multipla la costruzione o la distruzione dell'oggetto invoca i costruttori e il distruttore della classe genitore nella gerarchia delle classi che aumenta il sovraccarico.
- L'eredità singola è più rivolta alla specializzazione. Mentre l'eredità multipla è più verso la generalizzazione.
- Poiché l'ereditarietà singola ha un sovraccarico minore, ha meno tempo di esecuzione rispetto all'ereditarietà multipla.
Conclusione
L'ereditarietà facilita il lavoro del programmatore come se una classe fosse già formata, le sue caratteristiche possono essere adattate da altre se necessario. Sebbene l'identificatore di accesso limiti l'accesso ai membri di una classe base in un certo modo, ma rende i dati più sicuri. L'ereditarietà singola è in qualche modo più semplice e facile da implementare rispetto all'ereditarietà multipla. L'ereditarietà riduce la dimensione del codice oggetto, ma influisce anche sul tempo di esecuzione del programma.
