Destructor for koblet liste C ++

En koblet liste er en sekvensiell datastruktur med medlemmer som ikke er beholdt på samme minneplassering. Med andre ord, en koblet liste består av noder, som alle har en dataramme og en lenke til en annen node på listen. En koblet liste kan erklæres som en struktur eller en klasse i C++. Når et hvilket som helst objekt i klassen og dens elementer blir eliminert, blir destruktører vanligvis brukt til å omfordele lagring og utføre noen operasjoner. Destructor påberopes når et objekt i klassen når tilgangen eller blir bevisst kastet.

En destruktør har ingen parametere og returnerer ingenting. En destruktor har aldri blitt kalt eksplisitt. Destructor vil ha en lignende tittel som klassen, men den har et tild (~) før den. Hvis en liste ikke lenger blir brukt i hele programmet, vil den bli slettet ved å bruke en destruktør, for da kan lagringsplassen tatt opp av hver node bli gitt til systemet og opparbeidet. Den koblede listens destruktør kan slette listen. La oss snakke i detalj:

Implisitt definerte destruktør

Hvis en koblet liste ikke har noen brukerdefinert destruktør, vil kompilatoren spesifisere en destruktør som et lenkemedlem. En ikke-statisk koblet liste vil ikke bli ødelagt av en implisitt definert destruktør. En implisitt definert destruktørens eksplisitte eller virtuelle base-koblede liste kunne ikke bli ødelagt. Den implisitt spesifiserte destruktøren er virtuell, og omfordelingsmetoden returnerer en udefinert, avsluttet eller isolert prosedyre. Når en kompilator lokaliserer en implisitt definert destruktør som ikke er fjernet, er den spesifisert implisitt. Kroppen til denne implisitt erklærte destruktøren er tom.

#inkludere
ved hjelp av navneområdet STD;
struct link

int d;
lenke* Neste;
;
Klasselinje

privat:
lenke* først;
offentlig:
LinkList ()
først = null;
~ linkList ();
void addVal (int a);
void display ();
;
void linkList :: addVal (int a)

lenke* newLink = ny lenke;
newlink-> d = a;
newlink-> neste = først;
først = newlink;

void linkList :: display ()

I starten av programmet vil vi inkludere en overskriftsfil . Sammen med dette brukes også standard navneområdet. Vi erklærer ett medlem av listen som heter 'Link'. Variabelen 'D' for lagring av datasettet blir initialisert. Vi oppretter en peker for neste liste. Her konstruerer vi klassen kalt 'Linklist'. Det er en liste over lenker. Pekeren til den første lenken er satt som privat.

Konstruktøren av "Linklisten" har ingen parameter. Vi ga den 'første' lenken til verdien 'null'. Så har vi brukt destruktøren '~ LinkList ()'. I C ++ er en destruktor en metode som fjerner et element. Den har ingen inngangsparametere og ingen utgangstype. Vi vil legge til elementene i koblingslisten. Så vi bruker tomrommet addVal (). Denne funksjonen inneholder det nødvendige datasettet som et argument.

Vi har brukt Void Display () -funksjonen for å vise alle koblingene. Her oppretter vi en ny lenke. Vi gir datasettet til den nye lenken ved å bruke (->) operatøren. Denne operatøren peker på neste lenke. Den første koblingslistenes første element er pekt på den nye lenken. Vi må vise den spesifiserte koblede listen ved hjelp av Display () -funksjonen.

lenke* strøm = først;
mens (strøm != Null)

cout<Nåværende = strøm-> Neste;


LinkList :: ~ Linklist ()

lenke* strøm = først;
mens (strøm != Null)

lenke* temp = strøm;
Nåværende = strøm-> Neste;
slett temp;


int main ()

Linkliste L;
l.addVal (11);
l.addVal (22);
l.addVal (33);
l.addVal (44);
l.vise();
cout<retur 0;

I tillegg til dette setter vi pekeren '*strøm' til den første lenken. Vi bruker mens Loop her. Destructor blir brukt på 'Linklist'. Tilsvarende setter vi igjen pekeren til det første elementet i lenken og slutter på det siste elementet i lenken ved å bruke 'while' loop. Vi initialiserer en ny variabel, 'Temp', for å lagre den første lenkets peker. Operatøren (->) brukes til å skaffe pekeren til den nye lenken.

Derfor sletter vi "temp" -variabelen. Liket av hovedfunksjonen () startes. Dataene til denne koblede listen lagres i en variabel 'L'. Nå setter vi separat inn fire tilfeldige verdier i listen ved hjelp av L.addVal () -funksjon. Vi ansetter L.Display () Metode for å vise hele den koblede listen. Før vi går inn i 'retur o' -kommandoen, legger vi til 'endl'. Den skriver bare ut verdiene på den koblede listen i separate linjer.

Bruk av triviell destruktør

Den trivielle destruktøren blir ikke adressert direkte. De vil enten automatisk bli erklært eller eksplisitt erklært. Denne destruktøren er ikke dynamisk; Derfor er ikke destruktøren av foreldreklassen dynamisk. Destructors er trivielle i alle primære abstrakte klasser. Destructors er trivielle for noen ikke-statiske dataobjekter eller matriser av underklassen. Destructors blir ofte påkalt omvendt at konstruktører er. Elementer som har trivielle destruktører, ville ikke trenge en slettatning for å bli kastet; snarere kan de omfordeles.

#inkludere
ved hjelp av navneområdet STD;
Klassreiser
offentlig:
Reise()

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

cout<< "Destructor Invoked for Travel class" <
;
klassebil
offentlig:
Bil()

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

cout<< "Destructor Invoked for Car class" <
;
Int Main (Void)

Reise T1;
Bil C2;
retur 0;

Først av alt integrerer vi overskriftsfilen og standard navneområdet. Vi erklærer en koblet liste som en klasse 'reise'. Vi definerer konstruktøren av denne klassen offentlig. Vi har brukt 'cout' -kommandoen for å skrive ut teksten. Da er også destruktøren '~ reise ()' av klassen også bygget. For å vise linjen, går vi igjen inn i "cout" -erklæringen. Vi opprettet en andre klasse av programmet som heter 'Car'.

På samme måte definerer vi konstruktøren og destruktøren i denne klassen. Hovedfunksjonen () kalles. Objektet 'T1' for klassen 'Travel' og Object 'C2' av klassen 'Car' er blitt opprettet i kroppen til hoved- () -funksjonen (). Vi må oppgi kommandoen 'Return 0' for å avslutte programmet.

Konstruktøren av et objekt kalt 'T1' påkalles øyeblikkelig før du konstruerer objektet i den første delen av hoved- () -funksjonen. Så når 'C2' -objektet til 'Car' -klassen er laget i den andre funksjonslinjen Main (), kaller kompilatoren implisitt konstruktøren relatert til objektet 'C2'.

Destructors blir ofte påkalt i motsatt sekvens som konstruktører. Når konteksten til hoved- () -funksjonen avsluttes, kalles destruktøren assosiert med objektet 'C2' først. Etterpå blir destruktoren tilknyttet objekt 'T1' påkalt.

Konklusjon

I denne artikkelen har vi diskutert destruktøren for koblede lister i C++. Destructors vil aldri bli eksplisitt påberopt. Destructors har ikke en returerklæring. Vi kan implementere en destruktør for å avsløre lagring rett før den koblede listen blir slettet når en liste inneholder en peker til systemminnet. For å minimere bufferoverløp, kan dette utføres.