Introduzione a Destructor in C ++
Come tutti sappiamo, C ++ è un linguaggio di programmazione orientato agli oggetti ed è ampiamente utilizzato nelle industrie IT per lo sviluppo di software, driver, firmware incorporato e applicazioni client-server. È una lingua di livello intermedio che racchiude in sé le caratteristiche sia della lingua di alto livello che di quella di basso livello. Ha un concetto di classi e oggetti. In C ++, i costruttori svolgono un ruolo importante nella creazione di un oggetto e nell'inizializzazione delle variabili di istanza, ma cosa succede a questi oggetti e risorse dopo che non sono più in uso o al termine del programma? Questa responsabilità è curata dai distruttori in C ++. I distruttori sono usati per distruggere gli oggetti creati dai costruttori quando non sono più necessari per liberare la memoria. Sono funzioni speciali dei membri e chiamate automaticamente da C ++. compilatore per liberare la memoria quando non c'è nessun distruttore definito dall'utente nel programma. Come i costruttori, anche i distruttori hanno lo stesso nome della classe preceduta da un segno tilde (~). Ma il distruttore non accetta alcun argomento / parametro e non restituisce nulla, ovvero non ha alcun tipo di ritorno.
I distruttori non possono mai essere sovraccaricati come i costruttori in una classe. Di seguito sono riportate alcune delle situazioni in cui il distruttore viene chiamato automaticamente dal compilatore:
- Quando viene chiamato un operatore di eliminazione.
- Al termine dell'esecuzione del programma.
- Quando termina il blocco / ambito delle variabili locali.
Un programmatore può definire un distruttore noto come costruttore progettato dall'utente. Un distruttore può essere dichiarato come virtuale o puro virtuale ma non può essere dichiarato const, volatile, const volatile o statico.
Come funziona Destructor in C ++?
Per il funzionamento del distruttore è necessario tenere presente i seguenti punti:
- I distruttori di oggetti di classe vengono chiamati prima di chiamare il distruttore di membri e basi. I distruttori della classe base non virtuale vengono chiamati prima dei distruttori della classe base virtuale.
- Prima delle classi di base, viene chiamato il distruttore di membri non statici. I distruttori di classi base sia virtuali che non virtuali vengono chiamati nell'ordine inverso della loro dichiarazione.
- I distruttori impliciti vengono chiamati automaticamente dal compilatore C ++ quando un oggetto esce dall'ambito o l'esecuzione del programma termina per oggetti esterni e statici in un programma. I distruttori sono chiamati a distruggere gli oggetti creati da una nuova parola chiave.
- Nel caso di distruttori impliciti e definiti dall'utente, il compilatore esegue prima il corpo del distruttore, quindi chiama i distruttori di tutta la classe non variante non statica e quindi chiama i distruttori di classi di base non virtuali e virtuali nell'ordine inverso di la loro costruzione.
Sintassi di Destructor
I distruttori in C ++ sono preceduti dal segno tilde (~). Di seguito è menzionata la sintassi di base del distruttore:
Sintassi:
Class class_name()
(
…
…
public:
class_name(); // Constructor
~class_name(); // destructor
)
)
Nella sintassi, 'class_name' è il nome della classe e nel metodo principale sono definiti sia il costruttore che il distruttore con lo stesso nome della classe. Il distruttore non ha parametri né tipo restituito.
Esempi di distruttore in C ++
Di seguito è riportato l'esempio di Destructor in C ++:
Esempio n. 1: programma con distruttore definito dall'utente
Codice:
#include
using namespace std;
class Example1( //class
public:
Example1()( // constructor cout << “Hello I am inside a constructor” << endl;
)
~Example1()( //destructor
cout << “Hello I am inside a destructor” << endl;
)
void display()
(
cout << “Hello this is a display method” << endl
)
);
int main()
(
Example1 ex; //object created
ex.display(); // display method called return 0;
)
Produzione:
Nell'esempio sopra, "Esempio1" è il nome della classe e "ex" è l'oggetto creato di quella classe. Innanzitutto, viene chiamato il costruttore, quindi viene stampato il testo scritto nel costruttore, quindi il metodo di visualizzazione viene chiamato ana, infine, il distruttore viene chiamato dopo aver eseguito l'intera esecuzione del programma.
Esempio n. 2: programma con Virtual Destructor
Codice:
#include
using namespace std;
class b1 ( //base class
public:
b1() // constructor of base class
(
cout << “Hello this is base constructor” << endl;
)
~virtual b1() // destructor of base class
(
cout << “Hello this is base destructor” << endl;
)
);
class b2: public b1( // derived class of base class (b1) public:
b2() //constructor of derived cass
(
cout << “Hello this is derived constructor” << endl;
)
~ b2() // destructor of derived class
(
cout << “Hello this is derived destructor” << endl;
)
);
int main(void) //main method
(
b2 *der = new b2();
b1 *bas = der;
delete der;
getchar();
return 0;
)
Produzione:
È buona norma rendere virtuale il distruttore della classe base in quanto ciò garantisce che l'oggetto della classe derivata venga distrutto correttamente. Ogni volta che viene utilizzata una classe virtuale, è necessario aggiungere immediatamente un distruttore virtuale per evitare futuri risultati imprevisti.
Vantaggi di Destructor in C ++
- Offre la possibilità finale di ripulire le risorse non utilizzate per liberare la memoria occupata da oggetti inutilizzati come l'eliminazione di oggetti dinamici, la chiusura degli handle di sistema, i file utilizzati.
- A causa delle molte risorse che occupano spazio e che non vengono utilizzate nel computer, il distruttore viene sempre fornito con una buona immagine per ridurre le possibilità di perdita di memoria distruggendo quelle cose inutilizzate.
- Sebbene C ++ abbia il meccanismo di Garbage Collection ma chiamare automaticamente il distruttore indipendentemente dal fatto che il programmatore lo chiami o meno per liberare spazio impedisce all'utente di affrontare situazioni peggiori in futuro.
Punti da riassumere su Destructor
- I distruttori sono usati per distruggere le risorse inutilizzate di una classe.
- I distruttori hanno lo stesso nome del nome della classe che precede con il segno (~).
- A differenza dei costruttori, non può esserci alcun parametro del distruttore.
- Non esiste un tipo di ritorno di distruttore.
- Se l'utente non definisce il distruttore da solo in un programma, il compilatore costruisce automaticamente un distruttore per esso.
- Non ci può essere più di un distruttore in una singola classe.
Conclusione
La precedente descrizione dei distruttori definisce chiaramente l'uso e l'implementazione del distruttore nel programma C ++. Sebbene il concetto di distruttore non sia complesso, è molto importante capire prima dell'implementazione nel programma poiché l'uso improprio del distruttore può portare ad alcuni risultati inaspettati.
Articolo raccomandato
Questa è una guida a Destructor in C ++. Qui discutiamo Introduzione a Destructor in C ++ e Working of Destructor insieme a Vantaggi. Puoi anche consultare i nostri altri articoli suggeriti per saperne di più–
- Destructor in Java (Esempi)
- Introduzione alla sostituzione in C ++
- Pattern in C ++ (esempi)
- Tipi di costruttore in C ++
- Destructor in Python (Sintassi, Esempi)