C ++ eredità multipla
- Singola eredità
- Ereditarietà multipla
- Ereditarietà gerarchica
- Ereditarietà multilivello
- Ereditarietà ibrida
Qui il nostro argomento di discussione è molteplici eredità.
Ereditarietà multiple
L'eredità multipla si verifica quando più di una classe opera come classe genitore. Nel linguaggio di programmazione C ++, possiamo derivare una classe dalla classe base, ma possiamo anche derivare una classe da quelle classi che sono anche derivate da un'altra classe di base. Chiamiamo questo tipo di eredità ereditarietà multiple. Durante questo processo, si verificano anche alcuni problemi; Questi sono spiegati più avanti nella guida.
Scopo dell'eredità
L'eredità è uno degli approcci utili e importanti della OOP (programmazione orientata agli oggetti). Lo scopo principale dell'utilizzo dell'eredità in OOP o C ++ è consentire all'utente di riutilizzare il codice sorgente. Invece di scrivere lo stesso codice più volte, possiamo semplicemente usare l'eredità per ereditare le proprietà di una classe base alla classe figlio. Ciò riduce anche la complessità del codice sorgente.
La sintassi per le eredità multiple sono:
Classe 1
;
Classe 2: pubblico 1
;
Classe 3: pubblico 2
;
Per ereditare qualsiasi classe, il nome della classe figlio è scritto sul lato sinistro, mentre la classe genitore è scritta sul lato destro e questo è separato da un colon. Nella sintassi di cui sopra, la classe 2 deriva dalla classe 1 e la classe 3 deriva dalla classe 2.
Implementazione di eredità multipla
Esempio 1
Questo esempio è un campione di eredità in quanto molte eredità contengono un bambino con due genitori. Quindi qui, la classe C è una classe figlio, mentre la classe A e la classe B sono classi genitori. Ogni classe include un costruttore che visualizzerà un messaggio ogni volta che viene creato l'oggetto classe. L'uso della libreria iostream aiuta a dichiarare CIN, funzionalità cout. Entrambe le classi genitori sono dichiarate in alcun modo, ma mentre dichiarano la classe figlio, dobbiamo menzionare entrambe le classi genitori ereditate dalla classe figlio. Qui l'ordine di entrambe le classi deve essere tenuto a mente. La classe dichiarata per prima deve essere menzionata per ultima.
Ad esempio, nell'esempio dato, la classe A viene creata per prima nel codice sorgente da menzionare dopo B e la classe B verrà menzionata per prima.
Classe C: pubblico B, pubblico A
Creeremo un oggetto solo per la classe figlio nel programma principale, come nel processo di eredità, l'oggetto della classe figlio accede automaticamente alla classe genitore. Ora salva il file con il '.C 'estensione, compilare il codice tramite un compilatore G ++. '-o' viene utilizzato per salvare l'output del file.
$ g ++ -o multi -multi.C
$ ./Multi
Durante l'esecuzione riuscita, la risposta verrà visualizzata. Puoi vedere che il costruttore di Classe B verrà eseguito per primo solo a causa dell'ordine richiesto, sebbene sia stato dichiarato in seguito, quindi il costruttore della classe A viene eseguito e alla fine viene eseguita la stessa classe figlio.
Esempio 2
Ecco un esempio di eredità multiple in cui una "bambola" di classe infantile contiene due genitori, un giocattolo e un plushtoy. Queste classi sono dichiarate allo stesso modo che abbiamo fatto nell'ultimo esempio. Ogni costruttore viene creato per entrambe le classi genitori. La terza classe, la classe figlio, è dichiarata solo, ma il suo costruttore non è creato; C'è solo una dichiarazione. Qui l'ordine per la dichiarazione della classe genitore viene modificato, poiché il giocattolo di classe viene dichiarato per primo, deve essere menzionato in seguito, ma al momento della dichiarazione della classe figlio, viene menzionato per primo; Allo stesso modo, il phrushtoy di classe viene dichiarato in seguito menzionato anche dopo il giocattolo di classe.
Durante la creazione dell'oggetto, i costruttori della classe genitore verranno eseguiti a seconda dell'ordine menzionato mentre dichiara la classe figlio.
Ora esegui il codice; vedrai che il costruttore del giocattolo genitore viene eseguito per primo, quindi viene eseguito il costruttore della classe "plushtoy".
Esempio 3
Un problema di diamante si verifica nella situazione in cui due genitori (superclasse) hanno una classe base comune. Ad esempio, Child C ha due genitori, A e B, e questi appartengono entrambi a una singola Classe base D. Quindi, la classe C per bambini conterrà indirettamente due copie di Classe D, il che porta all'ambiguità. Questo problema è spiegato tramite codice sorgente C ++.
Una persona di classe viene creata come classe base e ha un costruttore per visualizzare un messaggio. Viene creata un'altra facoltà di classe che è un figlio della "persona" di classe base e ha un costruttore nella parte pubblica della classe. Come la facoltà, viene anche creato uno studente di classe che eredita dalla persona di classe di base dei genitori.
Facoltà e studenti diventano genitori superclasse in entrambe le classi quando un TA di classe è derivato da loro. Questa classe figlio TA è dichiarata avendo i nomi di entrambe le classi genitori.
Classe TA: facoltà pubblica: studente pubblico
Questo forma un diamante; Due classi ereditano una singola classe, mentre una singola classe è ereditata da queste due classi. Così indirettamente, la classe figlio conterrà dati della classe base dei suoi genitori.
La creazione di oggetti inizierà tutti i costruttori delle classi sopra descritte.
Quando il programma è eseguito, vedrai che il costruttore di classe di facoltà verrà eseguito per primo perché l'ordine era menzionato per primo mentre dichiarava una classe figlio. Quindi la lezione di facoltà visualizzerà prima il messaggio della classe persona e poi il suo messaggio; Allo stesso modo, la classe studentesca stamperà di nuovo la classe persona prima e poi il suo messaggio. E alla fine, viene visualizzato il messaggio di classe figlio.
Se viene dichiarato un processo o un'operazione nella classe base, verrà copiato due volte. Questo causerà ambiguità.
Per rimuovere questo problema, esiste una soluzione. La parola chiave "virtuale" viene utilizzata in questo aspetto. Utilizzando la parola chiave virtuale con la classe madre, la facoltà e lo studente eviteranno la creazione di due copie di una classe base. Questo viene applicato a un esempio visualizzato di seguito.
Il codice rimanente è lo stesso. Questo funzionerà in modo che il costruttore di classe di base (persona) sia chiamato per impostazione predefinita quando viene creato l'oggetto. Ciò eliminerà la duplicazione dello stesso messaggio o di qualsiasi operazione.
Ora eseguiremo il codice per vedere i risultati. Il costruttore di classe base viene eseguito solo una sola volta.
Conclusione
"Ereditarietà multipla C ++" contiene la spiegazione di base dell'eredità e la include nel codice. Alcuni esempi elementari sono implementati in C ++ per spiegare il funzionamento di eredità multiple. Questa guida viene fornita con alcuni importanti problemi di eredità come il problema del diamante. È elaborato in dettaglio e anche la soluzione ad esso è evidenziata. Spero che questo sforzo sarà una fonte di conoscenza completa per i nuovi utenti.