Introducere în distrugător în C ++
După cum știm cu toții, C ++ este un limbaj de programare orientat pe obiecte și este utilizat pe scară largă în industriile IT pentru dezvoltarea de software, drivere, firmware încorporate și aplicații client-server. Este un limbaj de nivel mediu, care încapsulează caracteristici atât ale nivelului înalt, cât și ale nivelului scăzut. Are un concept de clase și obiecte. În C ++, constructorii joacă un rol important în crearea unui obiect și inițializarea variabilelor de instanță, dar ce se întâmplă cu aceste obiecte și resurse după ce nu mai sunt utilizate sau programul se termină? Această responsabilitate este îngrijită de distrugătorii din C ++. Distrugătorii sunt folosiți pentru a distruge obiectele create de Constructori atunci când nu mai sunt necesare pentru a elibera memoria. Acestea sunt funcții speciale ale membrilor și sunt apelate automat de C ++. compilator pentru a elibera memoria atunci când în program nu există un distrugător definit de utilizator. La fel ca și Constructori, distrugătorii au același nume ca și clasa precedată de un semn tilde (~). Dar distrugătorul nu acceptă niciun argument / parametru și nu returnează nimic, adică nu au niciun tip de returnare.
Distrugătorii nu pot fi niciodată supraîncărcați ca niște constructori dintr-o clasă. Mai jos sunt prezentate câteva dintre situațiile în care distrugătorul este apelat automat de compilator:
- Când este apelat un operator de ștergere.
- Când execuția programului se termină.
- Când se termină blocul / sfera variabilelor locale.
Un programator poate defini un distrugător cunoscut sub numele de constructor proiectat de utilizator. Un distrugător poate fi declarat virtual sau pur virtual, dar nu poate fi declarat const, volatil, const volatil sau static.
Cum funcționează Distrugătorul în C ++?
Pentru lucrul cu distrugătorul trebuie să se țină cont de punctele menționate mai jos:
- Distrugătorii de obiecte de clasă sunt chemați mai întâi înainte de a chema distrugătorul membrilor și bazelor. Distrugătorii clasei de bază non-virtuale sunt numiți înaintea distrugătorilor clasei de bază virtuale.
- Înainte de clasele de bază, se numește distrugătorul membrilor nestatici. Distrugătoarele claselor de bază atât virtuale cât și non-virtuale sunt numite în ordinea inversă a declarației lor.
- Distructoarele implicite sunt numite automat de compilatorul C ++ atunci când un obiect iese din sfera de aplicare sau execuția programului se încheie pentru obiecte externe și statice dintr-un program. Distrugătorii sunt chemați să distrugă obiectele create de un nou cuvânt cheie.
- În cazul distructoarelor implicite și definite de utilizator, compilatorul execută mai întâi corpul distrugător și apoi apelează la distrugeri ale tuturor clasei non-statice non-variante și apoi apelează la distrugătoarele claselor de bază non-virtuale și virtuale în ordinea inversă a construcția lor.
Sintaxa distrugătorului
Distrugătorii din C ++ sunt precedați de semnul tilde (~). Mai jos menționată este sintaxa de bază a distrugătorului:
Sintaxă:
Class class_name()
(
…
…
public:
class_name(); // Constructor
~class_name(); // destructor
)
)
În sintaxă, „nume_ clasă” este numele clasei și în metoda principală sunt definite atât constructorul cât și distrugătorul cu același nume al clasei. Distrugătorul nu are niciun parametru și nici un tip de returnare.
Exemple de distrugător în C ++
Mai jos menționăm exemplul Distrugătorului în C ++:
Exemplul # 1: Program cu distrugător definit de utilizator
Cod:
#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;
)
ieşire:
În exemplul de mai sus, „Exemplul 1” este numele clasei și „ex” este obiectul creat de acea clasă. În primul rând, constructorul este numit, astfel că textul scris în constructor este tipărit, apoi metoda de afișare se numește ana, în sfârșit, distrugătorul este apelat după ce întreaga execuție a programului este făcută.
Exemplul # 2: Program cu distrugător virtual
Cod:
#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;
)
ieşire:
Este o practică bună să faci ca distrugătorul clasei de bază să fie cât mai virtual, deoarece acest lucru asigură că obiectul clasei derivate este distrus corect. Ori de câte ori este utilizată o clasă virtuală, trebuie adăugat imediat un distrugător virtual pentru a preveni rezultatele neașteptate viitoare.
Avantajele distrugătorului în C ++
- Oferă șansa finală de a curăța resursele care nu sunt utilizate pentru a elibera memoria ocupată de obiecte neutilizate, precum ștergerea obiectelor dinamice, aproape de mânerele sistemului, fișierele folosite.
- Din cauza multor resurse care ocupă spațiu și nu se obișnuiește în computer, destructorul vine întotdeauna cu o imagine bună pentru a reduce șansele de scurgere a memoriei prin distrugerea acelor lucruri neutilizate.
- Deși C ++ are mecanismul de colectare a gunoiului, dar apelarea automată a distrugătorului, indiferent dacă programatorul îl numește sau nu pentru a elibera spațiu, îl împiedică pe utilizator de multe situații mai grave în viitor.
Puncte de rezumat despre distrugător
- Distrugătorii sunt folosiți pentru a distruge resursele neutilizate ale unei clase.
- Distrugătorii au același nume cu numele clasei precedente cu semnul (~).
- Spre deosebire de Constructori, nu poate exista niciun parametru al distrugătorului.
- Nu există nici un tip de distrugere de retur.
- Dacă utilizatorul nu definește singur destructorul într-un program, compilatorul construiește automat un destructor pentru acesta.
- Nu poate exista mai mult de un distrugător într-o singură clasă.
Concluzie
Descrierea de mai sus a distrugătorilor definește clar utilizarea și implementarea destructorului în programul C ++. Deși conceptul de distrugător nu este complex, însă este foarte important să înțelegem înainte de implementarea în program, deoarece utilizarea necorespunzătoare a distrugătorului poate duce la rezultate neașteptate.
Articol recomandat
Acesta este un ghid pentru Distrugătorul din C ++. Aici discutăm Introducerea distrugătorului în C ++ și Lucrul distrugătorului împreună cu Avantaje. Puteți parcurge și alte articole sugerate pentru a afla mai multe -
- Distrugător în Java (Exemple)
- Introducere în suprasolicitarea în C ++
- Modele în C ++ (Exemple)
- Tipuri de constructor în C ++
- Distrugător în Python (Sintaxă, exemple)