Destruktor für verknüpfte Liste C ++

Eine verknüpfte Liste ist eine sequentielle Datenstruktur, wobei Mitglieder, die nicht im selben Speicherort aufbewahrt werden. Mit anderen Worten, eine verknüpfte Liste besteht aus Knoten, die alle einen Datenrahmen und einen Link zu einem anderen Knoten in der Liste haben. Eine verknüpfte Liste kann als Struktur oder Klasse in C deklariert werden++. Wenn ein Objekt der Klasse und ihrer Elemente beseitigt wird. Der Destruktor wird angerufen, wenn ein Objekt der Klasse seinen Zugang erreicht oder absichtlich verworfen wird.

Ein Destruktor hat keine Parameter und gibt nichts zurück. Ein Destruktor wurde nie explizit genannt. Der Destruktor wird einen ähnlichen Titel wie die Klasse haben, aber es hat eine Tild (~) davor. Wenn eine Liste im gesamten Programm nicht mehr verwendet wird, wird sie mit einem Destruktor gelöscht. Der Destruktor der verknüpften Liste kann die Liste löschen. Lassen Sie uns im Detail sprechen:

Implizit definierten Destruktor

Wenn eine verknüpfte Liste keinen benutzerdefinierten Destruktor hat, gibt der Compiler einen Destruktor als Linkmitglied an. Eine nicht statische verknüpfte Liste wird von einem implizit definierten Destruktor nicht am Boden zerstört. Eine explizite oder virtuelle, basis verlinkte Liste eines implizit definierten Destruktors konnte nicht zerstört werden. Der implizit spezifizierte Destruktor ist virtuell, und die Neuverzögerungsmethode gibt ein undefiniertes, beendetes oder isoliertes Verfahren zurück. Wenn ein Compiler einen implizit definierten Destruktor lokalisiert, der nicht entfernt wird, ist er implizit angegeben. Der Körper dieses implizit erklärten Destruktors ist leer.

#enthalten
Verwenden von Namespace STD;
Strukturverbindung

int d;
Link* Weiter;
;
Klasse LinkList

Privatgelände:
Link* zuerst;
öffentlich:
linkList ()
first = null;
~ linkList ();
void addval (int a);
void display ();
;
void linkList :: addval (int a)

Link* newlink = neuer Link;
newlink-> d = a;
newlink-> next = zuerst;
first = newlink;

void linkList :: display ()

Zu Beginn des Programms werden wir eine Header -Datei angeben . Zusammen mit diesem wird auch der Standard -Namespace verwendet. Wir deklarieren ein Mitglied der Liste mit dem Namen "Link". Die Variable 'D' zum Speichern des Datensatzes wird initialisiert. Wir erstellen einen Zeiger für die nächste Liste. Hier konstruieren wir die Klasse als "LinkList" als "LinkList". Es ist eine Liste von Links. Sein Zeiger auf den ersten Link wird als privat festgelegt, und der Konstruktor wird öffentlich festgelegt.

Der Konstruktor der "LinkList" hat keinen Parameter. Wir haben den "ersten" Link zum Wert "Null" bereitgestellt. Dann haben wir den Destructor '~ linkList ()' verwendet. In C ++ ist ein Destruktor eine Methode, die ein Element beseitigt. Es hat keine Eingabeparameter und keinen Ausgangstyp. Wir werden die Elemente zur Linkliste hinzufügen. Also wenden wir die void addval () -Funktion an. Diese Funktion enthält den erforderlichen Datensatz als Argument.

Wir haben die Funktion void display () verwendet, um alle Links anzuzeigen. Hier erstellen wir einen neuen Link. Wir stellen den Datensatz für den neuen Link mit dem Operator (->) an. Dieser Betreiber verweist auf den nächsten Link. Das erste Element der ersten Linkliste wird auf den neuen Link hingewiesen. Wir müssen die angegebene verknüpfte Liste mit der Funktion display () anzeigen.

Link* current = zuerst;
während (aktuell != Null)

Cout<Strom = Strom-> Weiter;


linkList :: ~ linkList ()

Link* current = zuerst;
während (aktuell != Null)

Link* temp = aktuell;
Strom = Strom-> Weiter;
Temperatur löschen;


int main ()

LinkList L;
l.Addval (11);
l.Addval (22);
l.Addval (33);
l.Addval (44);
l.Anzeige();
Cout<Rückkehr 0;

Darüber hinaus setzen wir den Zeiger "*aktuell" auf den ersten Link. Wir wenden die while -Schleife hier an. Der Destruktor wird auf der "LinkList" angewendet. In ähnlicher Weise setzen wir den Zeiger erneut auf das erste Element des Link. Wir initialisieren eine neue Variable, "Temp", um den Zeiger des ersten Links zu speichern. Der (->) Operator wird verwendet, um den Zeiger auf den neuen Link zu erwerben.

Daher löschen wir die "Temp" -Variable. Der Körper der Main () -Funktion wird begonnen. Die Daten dieser verknüpften Liste werden in einer Variablen 'l' gespeichert. Jetzt fügen wir mit Hilfe des l vier zufällige Werte separat in die Liste ein.Addval () Funktion. Wir beschäftigen das l.Anzeige () Methode zur Anzeige der gesamten verknüpften Liste. Bevor wir in den Befehl 'return o' eingeben, fügen wir 'endl' hinzu. Es druckt nur die Werte der verknüpften Liste in separaten Zeilen.

Verwendung von trivialen Zerstörer

Der triviale Destruktor wird nicht direkt angesprochen. Sie werden entweder automatisch deklariert oder ausdrücklich deklariert. Dieser Destruktor ist nicht dynamisch; Daher ist der Destruktor der Elternklasse nicht dynamisch. Zerstörer sind in allen primären abstrakten Klassen trivial. Zerstörer sind für einige nicht statische Datenobjekte oder Arrays der Unterklasse trivial. Zerstörer werden häufig umgekehrt angerufen, dass Konstruktoren sind. Elemente mit trivialen Zerstörern müssten keine Löschdatenbeschäftigung benötigen, um verworfen zu werden. Vielmehr können sie neu zugewiesen werden.

#enthalten
Verwenden von Namespace STD;
Klassenreisen
öffentlich:
Reisen()

Cout<< "Constructor Invoked for Travel class" <
~ Reise ()

Cout<< "Destructor Invoked for Travel class" <
;
Klassenauto
öffentlich:
Auto()

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

Cout<< "Destructor Invoked for Car class" <
;
int main (void)

Reise T1;
Auto C2;
Rückkehr 0;

Zunächst integrieren wir die Header -Datei und den Standard -Namespace. Wir deklarieren eine verknüpfte Liste als Klasse "Reise". Wir definieren den Konstruktor dieser Klasse öffentlich. Wir haben den Befehl "Cout" verwendet, um den Text zu drucken. Dann wird auch der Destruktor '~ tave ()' der Klasse gebaut. Zum Anzeigen der Zeile geben wir erneut die Anweisung "Cout" ein. Wir haben eine zweite Klasse des Programms namens "Car" erstellt.

Auf die gleiche Weise definieren wir den Konstruktor und Destruktor dieser Klasse. Die main () -Funktion wird aufgerufen. Das Objekt 'T1' der Klasse 'Reise' und Objekt 'C2' des Klassenautos 'wurde im Körper der Main () -Funktion erstellt. Wir müssen den Befehl 'return 0' eingeben, um das Programm zu beenden.

Der Konstruktor eines Objekts, das als "T1" bezeichnet wird. Immer wenn das 'C2' -Objekt der 'Car' -Klasse in der zweiten Funktionslinie Main () hergestellt wird, ruft der Compiler den Konstruktor implizit auf, das sich auf das Objekt 'C2' bezieht.

Destruktoren werden oft in der entgegengesetzten Sequenz als Konstruktoren angerufen. Sobald der Kontext der Funktion main () beendet wird, wird der mit dem Objekt 'C2' zugeordnete Zerstörer zuerst bezeichnet. Danach wird der mit dem Objekt 'T1' verbundene Zerstörer aufgerufen.

Abschluss

In diesem Artikel haben wir den Destruktor für verknüpfte Listen in C erörtert++. Zerstörer werden niemals explizit aufgerufen. Zerstörer haben keine Rückkehrerklärung. Wir können einen Destruktor implementieren, um den Speicher kurz vor dem Löschen der verlinkten Liste zu enthüllen, wenn eine Liste einen Zeiger auf den Systemspeicher enthält. Um Pufferüberläufe zu minimieren, kann dies durchgeführt werden.