Destructor per l'elenco collegato C ++

Un elenco collegato è una struttura di dati sequenziali con membri non mantenuti nella stessa posizione di memoria. In altre parole, è costituito un elenco collegato da nodi, che hanno tutti un frame di dati e un collegamento a un altro nodo nell'elenco. Un elenco collegato può essere dichiarato come una struttura o una classe in C++. Quando qualsiasi oggetto della classe e dei suoi elementi viene eliminato, i distruttori vengono generalmente utilizzati per riallocare l'archiviazione ed eseguire alcune operazioni. Il distruttore viene invocato quando un oggetto della classe raggiunge il suo accesso o viene deliberatamente scartato.

Un distruttore non ha parametri e non restituisce nulla. Un distruttore non è mai stato chiamato esplicitamente. Il Destructor avrà un titolo simile alla classe, ma ha un Tild (~) prima di essa. Se un elenco non viene più utilizzato nell'intero programma, verrà eliminato utilizzando un distruttore perché lo spazio di archiviazione occupato da ogni nodo potrebbe essere fornito al sistema e rielaborato. Il distruttore dell'elenco collegato può eliminare l'elenco. Parliamo in dettaglio:

Distruttore implicitamente definito

Se un elenco collegato non ha un distruttore definito dall'utente, il compilatore specificherà un distruttore come membro del collegamento. Un elenco collegato non statico non sarà devastato da un distruttore implicitamente definito. L'elenco esplicito o virtuale di una base virtuale di Destructor implicitamente definita non potrebbe essere distrutto. Il distruttore implicitamente specificato è virtuale e il metodo di riallocazione restituisce una procedura non definita, terminata o isolata. Quando un compilatore individua un distruttore implicitamente definito che non viene rimosso, viene specificato implicitamente. Il corpo di questo distruttore implicitamente dichiarato è vuoto.

#includere
Utilizzo dello spazio dei nomi std;
Link struct

int d;
Link* Next;
;
Linklist di classe

privato:
Link* prima;
pubblico:
LinkList ()
First = null;
~ linkList ();
void addval (int a);
void display ();
;
void LinkList :: AddVal (int a)

link* newlink = new Link;
newlink-> d = a;
newlink-> next = first;
Primo = newlink;

void LinkList :: Display ()

All'inizio del programma, includeremo un file di intestazione . Insieme a questo, viene utilizzato anche lo spazio dei nomi standard. Dichiariamo un membro dell'elenco chiamato "link". La variabile 'd' per la memorizzazione del set di dati viene inizializzata. Creiamo un puntatore per l'elenco successivo. Qui costruiamo la classe definita "Linklist". È un elenco di collegamenti. Il suo puntatore al primo collegamento è impostato come privato e il costruttore è impostato pubblicamente.

Il costruttore di "Linklist" non ha un parametro. Abbiamo fornito il collegamento "primo" al valore "null". Quindi abbiamo usato il Destructor '~ LinkList ()'. In C ++, un distruttore è un metodo che rimuove un elemento. Non ha parametri di input e nessun tipo di output. Aggiungeremo gli elementi all'elenco dei collegamenti. Quindi applichiamo la funzione void addVal (). Questa funzione contiene il set di dati richiesto come argomento.

Abbiamo utilizzato la funzione void display () per visualizzare tutti i collegamenti. Qui creiamo un nuovo link. Forniamo il set di dati al nuovo collegamento utilizzando l'operatore (->). Questo operatore indica il collegamento successivo. Il primo elemento del primo elenco di collegamenti è indicato sul nuovo link. Dobbiamo visualizzare l'elenco collegato specificato usando la funzione display ().

link* corrente = primo;
mentre (corrente != Null)

cout<Current = Current-> Next;


LinkList :: ~ LinkList ()

link* corrente = primo;
mentre (corrente != Null)

link* temp = corrente;
Current = Current-> Next;
Elimina temp;


int main ()

Linklist L;
l.AddVal (11);
l.AddVal (22);
l.AddVal (33);
l.AddVal (44);
l.Schermo();
cout<restituzione 0;

Oltre a ciò, impostiamo il puntatore '*corrente' sul primo link. Applichiamo il ciclo while qui. Il Destructor viene applicato su "Linklist". Allo stesso modo, impostiamo di nuovo il puntatore sul primo elemento del collegamento e abbiamo lasciato l'ultimo elemento del collegamento usando il ciclo "while". Inizializziamo una nuova variabile, "temp", per archiviare il puntatore del primo link. L'operatore (->) viene utilizzato per acquisire il puntatore al nuovo collegamento.

Quindi eliminiamo la variabile "temp". Il corpo della funzione principale () viene avviato. I dati di questo elenco collegato sono archiviati in una variabile 'L'. Ora inseriamo separatamente quattro valori casuali nell'elenco con l'aiuto di L.funzione addVal (). Impieghiamo il l.Metodo Display () per mostrare l'intero elenco collegato. Prima di inserire il comando "return o", aggiungiamo "endl". Stampa semplicemente i valori dell'elenco collegato in righe separate.

Uso del banale distruttore

Il banale distruttore non viene affrontato direttamente. Saranno dichiarati automaticamente o dichiarati esplicitamente. Questo distruttore non è dinamico; Pertanto, il distruttore della classe genitore non è dinamico. I distruttori sono banali in tutte le classi astratte primarie. I distruttori sono banali per alcuni oggetti o array di dati non statici della sottoclasse. I distruttori sono spesso inversamente inversamente che i costruttori lo sono. Gli elementi che hanno distruttori banali non avrebbero bisogno di una dichiarazione di eliminazione per essere scartati; Piuttosto, possono essere riallocati.

#includere
Utilizzo dello spazio dei nomi std;
Class Travel
pubblico:
Viaggio()

cout<< "Constructor Invoked for Travel class" <
~ Viaggi ()

cout<< "Destructor Invoked for Travel class" <
;
Class Car
pubblico:
Auto()

cout<< "Constructor Invoked for Car class" <
~ Car ()

cout<< "Destructor Invoked for Car class" <
;
int main (vuoto)

Viaggiare T1;
Auto c2;
restituzione 0;

Prima di tutto, integriamo il file di intestazione e lo spazio dei nomi standard. Dichiariamo un elenco collegato come una classe "viaggio". Definiamo pubblicamente il costruttore di questa classe. Abbiamo utilizzato il comando "cout" per stampare il testo. Quindi viene costruito anche il Destructor '~ Travel ()' della classe. Per la visualizzazione della riga, inseriamo nuovamente l'istruzione "cout". Abbiamo creato una seconda classe del programma denominato "auto".

Allo stesso modo, definiamo il costruttore e il distruttore di questa classe. La funzione principale () viene chiamata. L'oggetto "T1" della classe "viaggio" e oggetto "C2" della classe "auto" è stato creato all'interno del corpo della funzione principale (). Dobbiamo inserire il comando 'return 0' per terminare il programma.

Il costruttore di un oggetto chiamato "T1" viene immediatamente invocato prima di costruire l'oggetto nella prima sezione della funzione principale (). Quindi, ogni volta che l'oggetto "C2" della classe "auto" viene realizzato nella seconda linea di funzione main (), il compilatore chiama implicitamente il costruttore relativo all'oggetto "C2".

I distruttori sono spesso invocati nella sequenza opposta come costruttori. Una volta terminato il contesto della funzione principale (), il distruttore associato all'oggetto 'C2' viene chiamato per primo. Successivamente, viene invocato il distruttore associato all'oggetto "T1".

Conclusione

In questo articolo, abbiamo discusso del Destructor per gli elenchi collegati in C++. I distruttori non saranno mai esplicitamente invocati. I distruttori non hanno una dichiarazione di ritorno. Possiamo implementare un distruttore per rivelare l'archiviazione poco prima che l'elenco collegato venga eliminato quando un elenco include un puntatore alla memoria di sistema. Per ridurre al minimo gli overflow buffer, questo può essere eseguito.