Tuttavia, potrebbe esistere un distruttore virtuale. Qui mostreremo cosa succede quando creiamo un costruttore virtuale in C++ e il funzionamento del distruttore virtuale invece del costruttore virtuale.
Esempio 1:
Creiamo il costruttore virtuale e iniziamo il nostro codice inserendo il file di intestazione 'iostream'. Questo file di intestazione è per le funzioni dichiarate in esso come 'cin' e 'cout'. Successivamente, aggiungiamo lo spazio dei nomi 'std', quindi non possiamo aggiungere questo 'std' con ogni funzione nel nostro codice. Successivamente, creiamo una classe che è la classe base del nostro codice con il nome 'my_base' e quindi aggiungiamo 'public' per creare il costruttore virtuale.
Il costruttore virtuale viene creato qui inserendo la parola chiave “virtuale”. All'interno di questo costruttore virtuale inseriamo un'istruzione 'cout'. Al di sotto di questo, creiamo una funzione denominata 'show' in cui utilizziamo nuovamente il 'cout'. Successivamente creiamo una classe derivata da questa classe base con il nome “my_derived” e quindi stabiliamo il costruttore “my_derived()” nel campo “public”. Inseriamo un'istruzione 'cout' in questo costruttore 'my_derived()'. Sotto di esso, costruiamo una funzione chiamata “show” in cui utilizziamo ancora una volta il “cout”.
Ora, dopo aver invocato “main()”, creiamo un puntatore della classe base con il nome “my_ptr” e creiamo anche l'oggetto della classe derivata che è “Obj_d”. Successivamente, assegniamo l'indirizzo di “Obj_d” a “my_ptr”. Quindi, chiamiamo la funzione “show()” tramite “my_ptr”.
Codice 1:
#include
utilizzando spazio dei nomi standard ;
classe mia_base
{
pubblico :
virtuale mia_base ( )
{
cout << 'Ecco la mia classe base' << fine ;
}
vuoto spettacolo ( )
{
cout << 'la funzione mostra della classe base' << fine ;
}
} ;
classe mio_derivato : pubblico mia_base
{
pubblico :
mio_derivato ( )
{
cout << 'Ecco la mia classe derivata' << fine ;
}
vuoto spettacolo ( )
{
cout << 'la funzione mostra della classe derivata' < spettacolo ( ) ;
}
Produzione:
Qui mostra un messaggio di errore che dice che il costruttore non può essere dichiarato virtuale nella programmazione C++. Quindi, possiamo vedere che il C++ non ci consente di generare il costruttore virtuale ma possiamo creare il distruttore virtuale.
Esempio 2:
Risolviamo il problema precedente e creiamo il distruttore virtuale in questo codice. Dopo aver dichiarato la classe “new_base”, inseriamo il costruttore “public” in cui creiamo il distruttore virtuale aggiungendo “virtual ~” con “new_base”. Inseriamo un'istruzione 'cout' in questo distruttore virtuale. Sotto di esso, costruiamo una funzione chiamata “show” che fa uso del “cout”. Successivamente, creiamo una classe derivata che è “new_derived” di questa classe base “new_base” e costruiamo il distruttore “new_derived()” nel campo “public”. A questo distruttore 'new_derived()' è ora aggiunta un'istruzione 'cout'.
Sotto di esso creiamo una funzione chiamata 'show' che utilizza nuovamente l'istruzione 'cout'. Dopo aver chiamato la funzione “main()”, ora produciamo un oggetto della classe derivata “obj_d” e un puntatore della classe base denominato “ptr1”. Successivamente, diamo l'indirizzo 'obj_d' a 'ptr1'. Successivamente, il metodo 'show()' viene richiamato utilizzando 'ptr1'.
Codice 2:
#includeutilizzando spazio dei nomi standard ;
classe nuova_base
{
pubblico :
virtuale ~nuova_base ( )
{
cout << 'Il distruttore della classe base è qui' << fine ;
}
vuoto spettacolo ( )
{
cout << 'La funzione show della classe base' << fine ;
}
} ;
classe nuovo_derivato : pubblico nuova_base
{
pubblico :
~nuovo_derivato ( )
{
cout << 'Il distruttore della classe derivata è qui' << fine ;
}
vuoto spettacolo ( )
{
cout << 'La funzione show della classe base' < spettacolo ( ) ;
}
Produzione:
Questo programma utilizza un oggetto puntatore di 'new_base' che punta alla classe derivata 'obj_d'. Pertanto, chiama prima il metodo “show()” della classe “new_base”. Quindi, chiama il metodo “~new_derived()” della classe “new_derived” e visualizza “~new_base” della classe base.
Esempio 3:
Ecco un altro codice per generare il costruttore “virtuale”. Dopo aver incluso il namespace “iostream” e “std”, generiamo una classe “B”. Al di sotto di questo, creiamo il costruttore “pubblico” che è “B()” e quindi generiamo il “cout”. Le funzioni di costruzione e distruzione vengono definite utilizzando uno specificatore di accesso 'pubblico' in cui qualsiasi oggetto nella classe può chiamare.
Ora creiamo anche il distruttore “~B()” di questa classe base in cui utilizziamo nuovamente “cout”. Quindi, creiamo la classe “D” che è la classe derivata della classe base “B” e inseriamo qui il “pubblico”. All'interno di questo “public”, creiamo sia il costruttore che il distruttore della classe derivata con i nomi “D()” e “~D”, rispettivamente. Entrambi contengono al loro interno il “cout”. Ora abbiamo la funzione “main()”. Dopo aver chiamato questa funzione, generiamo l'oggetto puntatore della classe base.
Quindi, utilizziamo la parola chiave 'delete' e inseriamo qui 'base_ptr'. In questo caso, lo spazio del distruttore viene cancellato chiamando l’oggetto puntatore della classe base.
Codice 3:
#includeutilizzando spazio dei nomi standard ;
classe B
{
pubblico :
B ( )
{
cout << 'Costruttore della classe Base' << fine ;
}
~B ( )
{
cout << 'Distruttore della classe Base' << fine ;
}
} ;
classe D : pubblico B
{
pubblico :
D ( )
{
cout << 'Costruttore della classe derivata' << fine ;
}
~D ( )
{
cout << 'Distruttore della classe derivata' << fine ;
}
} ;
int principale ( )
{
B * base_ptr = nuovo D ;
eliminare base_ptr ;
}
Produzione:
Il risultato mostra che utilizza un oggetto puntatore che punta alla classe “B” nella funzione principale. Pertanto, chiama prima il 'costruttore()' della classe 'B'. Quindi, chiama il 'costruttore()' della classe 'D'. L'oggetto puntatore conservato dai distruttori delle classi “B” e “D” viene quindi eliminato. Senza invocare il distruttore della classe “D” all'interno del programma, il puntatore della classe “B” elimina solo il distruttore della classe “B”. Di conseguenza, la memoria del programma è danneggiata.
Conclusione
Abbiamo discusso il concetto di “costruzione virtuale” nella programmazione C++. Abbiamo esplorato il fatto che non possiamo creare il costruttore virtuale in C++, ma possiamo creare il distruttore virtuale nei nostri codici. Qui abbiamo mostrato cosa succede quando creiamo il costruttore virtuale nella programmazione C++ e il funzionamento del distruttore virtuale nei nostri codici. Abbiamo imparato che il costruttore non può essere virtuale, ma possiamo generare il distruttore virtuale nella nostra classe. Abbiamo dimostrato alcuni esempi e spiegato approfonditamente questi codici in questa guida.