Problema del diamante C ++
Per eseguire i programmi relativi a "C ++ Diamond Eredità" nel sistema operativo Linux, è necessario avere un sistema Ubuntu installato ed in esecuzione sulla macchina virtuale. Vengono utilizzati due strumenti. Uno è qualsiasi strumento di modifica e, come tale, useremo il "editor di testo" predefinito di Linux. È possibile utilizzare altri strumenti di editing preferiti. Il secondo è il terminale Ubuntu. Su cui eseguirai il programma e vedrai l'output visualizzato.
Innanzitutto, discuteremo più eredità nell'articolo, poiché il "problema dei diamanti" si verifica nel caso di avere eredità nel codice sorgente.
Ereditarietà multiple in C++
Quando parliamo dell'uso delle classi gerarchicamente nel programma, sappiamo sempre OOP (programmazione orientata agli oggetti). Perché questa eredità è una caratteristica importante dell'orientata agli oggetti, in cui una sottoclasse è in grado di ereditare da una o più superclassi. In questo modo, una classe per bambini ha due o più genitori.
Ad esempio, se una madre e un padre hanno un figlio in uno scenario della vita reale, il bambino erediterà tutto dai genitori. Quindi questo bambino è noto per essere una classe derivata con madre e padre come genitori. Torniamo alle molteplici eredità. Useremo i "costruttori" come parte della nostra discussione attuale. I costruttori di una classe ereditaria (classe figlio) in eredità multiple eseguono seguendo il loro ordine ereditato. Considerando che per i distruttori, l'ordine è il contrario dell'eredità. Ora citeremo un semplice esempio per dimostrare la funzionalità dell'eredità in C++.
Esempio di eredità multiple
Considera un esempio in cui ci sono due classi, Classe A e Classe B, come classe Parente, e queste due classi hanno una classe figlio denominata Classe C. Questa classe è una classe derivata di entrambi i suoi genitori. Useremo un costruttore nella parte pubblica di ogni classe.
Il primo passo nel codice è utilizzare una libreria per consentire lo streaming input-output:
Quindi dobbiamo dichiarare la classe A, avere i costruttori con il nome della classe. Come sai che i costruttori sono dichiarati con il nome di quella classe, e questi vengono chiamati ogni volta che viene creato l'oggetto. Nel costruttore, è stato visualizzato un semplice messaggio che mostra quale costruttore di classe viene eseguito. Ora, definiamo la classe B con lo stesso approccio. Dopo entrambe le classi genitori, viene menzionata la classe figlio.
Una cosa che si dovrebbe notare qui è l'ordine delle classi genitori che il bambino eredita perché questo ordine avrà importanza al momento dell'esecuzione del costruttore e un messaggio che mostra.
Ora, nella classe principale, creeremo un oggetto della classe figlio. Poiché ha eredità multiple, non è necessario creare l'oggetto per la classe genitore. Vengono eseguiti automaticamente a causa dell'oggetto della classe figlio:
Int main ()
C c;
Restituzione 0;
Dopo aver scritto il codice precedente nell'editor di testo, salva questo file con l'estensione di ".C'. Eseguiremo il file nel terminale Ubuntu. Ai fini dell'esecuzione, è richiesto un compilatore. In C ++, utilizziamo un compilatore G ++. Altrimenti, è necessario prima installarlo:
$ G ++ -o m1 m1.C
$ ./M1
Usa G ++ con il nome del file con il codice sorgente e quello in cui si desidera mostrare l'output. Nota, -O viene utilizzato per salvare l'output. Poiché la Classe B è ereditata sopra la Classe A, quindi il suo costruttore viene eseguito per primo, è possibile vedere l'output dall'immagine precedente.
Poiché il concetto di eredità è chiaro ora, discuteremo del "problema dei diamanti" qui.
Problema di diamanti
Un problema di diamanti è un caso solo in eredità multiple che si verifica quando una classe infantile ha i valori ereditati dai due genitori. In cui queste classi genitori sono ereditate da una classe di nonni comune.
Ad esempio, considera un esempio in cui abbiamo una classe figlio ereditata dalle classi di madre e padre. Queste classi ereditano una terza classe chiamata "persona":
Bambino> madre> persona
> Padre> Persona
Quindi, secondo lo scenario dato, la classe figlio eredita la classe "persona" due volte nel programma. Una volta, viene dalla madre e, di nuovo, la seconda volta è dal padre. Questo crea confusione per il compilatore per eseguire prima il costruttore. Questa situazione provoca un grafico ereditario a forma di diamante. Quindi, è noto come "il problema del diamante".
L'approccio del codice è quasi lo stesso. Dichiarare la classe base e poi due lezioni ereditate figlio (madre, padre) della classe base. Ogni classe è seguita dal costruttore con una variabile per archiviare un valore in esso:
Ora, introducendo la classe figlio:
# Class Child: Public Father, Public Mother
La classe figlio erediterà entrambe le classi genitori. La funzione principale utilizzerà l'oggetto del figlio e un valore nel parametro della chiamata del costruttore:
Dopo aver salvato il codice, è tempo di utilizzare il compilatore per l'esecuzione e vedere il risultato:
Ora, puoi osservare che la classe di base è chiamata due volte. Questo è un problema di diamante. Dopo aver descritto il problema, ora troveremo una possibile soluzione.
Soluzione del problema del diamante
La soluzione dipende dall'uso della parola chiave "virtuale". Le classi a due genitori con una classe di base comune erezzeranno ora la classe di base praticamente per ridurre al minimo il verificarsi di copie della classe base nella classe figlio. Ora modificheremo il codice utilizzando quella parola chiave:
Ogni volta che la classe genitore eredita dalla classe nonna, viene utilizzato "virtuale" ma solo con i genitori, non nel caso di un bambino. Questa è "l'eredità virtuale". Limita il passaggio di più di una singola istanza dalla classe base da passare.
# Classe Padre: persona pubblica virtuale
Ora eseguiremo il codice. I valori risultanti mostrano che l'ambiguità viene rimossa usando questo concetto:
Per evitare la ripetizione del costruttore di base da chiamare, il costruttore per una classe di base virtuale non viene raggiunto attraverso la classe che l'ha ereditata. Tuttavia, questo costruttore viene chiamato dal costruttore di classe concreta. Nell'esempio attuale, la classe figlio chiama direttamente il costruttore di classe "persona".
Conclusione
"C ++ Diamond Problem" è un articolo scritto per rimuovere l'ambiguità della ripetizione della classe base in eredità multiple. Il concetto di eredità è spiegato brevemente con esempi. Allo stesso modo, la causa e la soluzione per il problema del diamante sono anche elaborati in dettaglio. Speriamo che questo tutorial possa fornirti una guida nel campo dei programmi C ++.