b"\n_START_ARTICLE_\nDistruttore (informatica)\n_START_SECTION_\nUso\n_START_PARAGRAPH_\nNella creazione del codice di un distruttore occorre agire con particolare attenzione, in quanto per evitare fenomeni di memory leak si deve essere certi che tutte le strutture dati liberino correttamente la memoria da loro utilizzata compresa quella eventualmente utilizzata da altre strutture annidate al loro interno._NEWLINE_Il distruttore, a differenza del costruttore, non pu\xc3\xb2 accettare nessun tipo di parametro, perch\xc3\xa9 se non chiamato esplicitamente, sar\xc3\xa0 il compilatore a inserire a fine programma la chiamata al distruttore. Per questo motivo, per ogni classe pu\xc3\xb2 esserci un solo distruttore, rendendo impossibile l'overloading._NEWLINE_ATTENZIONE: non \xc3\xa8 obbligatorio che un distruttore sia dichiarato public!_NEWLINE_L'esempio: _NEWLINE_class A {int i;_NEWLINE_       ~A() {} _NEWLINE_public: A(int v) {i=v;} _NEWLINE_};int main(int argc, char* argv[]){_NEWLINE_  A *a = new A(2); // ok_NEWLINE_  // A b(1);  <----- non ammesso perch\xc3\xa9 il distruttore \xc3\xa8 privato (error C2248: 'A::~A' : cannot access private member declared in class 'A')}_NEWLINE_compila perfettamente ma impedisce che un oggetto di classe A venga istanziato sullo stack ma consente che venga instaziato sullo heap. \xc3\x88 ovvio tuttavia che un metodo di distruzione debba essere fornito all'utente il quale, a questo punto, pu\xc3\xb2 accettare anche dei parametri e tornare dei valori. _NEWLINE_Esempio:_NEWLINE_class A {int i;static int count;_NEWLINE_                ~A ()     {}public:          A (int v){i=v; count++;}static bool Delete (A *a) {if (!count) return false; count--; delete a; return true;}};int A::count = 0;int main(int argc, char* argv[]){_NEWLINE_  A *a = new A(2);_NEWLINE_  bool b = A::Delete (a);// b=1_NEWLINE_  b = A::Delete (a);     // b=0}\n_START_SECTION_\nLinguaggi garbage collected\n_START_PARAGRAPH_\nNei linguaggi che mettono a disposizione un garbage collector, il distruttore \xc3\xa8 spesso inutile in quanto le risorse occupate da un oggetto vengono automaticamente liberate nel momento in cui non c'\xc3\xa8 pi\xc3\xb9 nessun riferimento all'oggetto stesso. In questi linguaggi \xc3\xa8 generalmente possibile utilizzare o definire ugualmente appositi metodi per ottenere il medesimo effetto, nei casi in cui si desideri disattivare il garbage collector, in quanto per alcuni task critici potrebbe risultare troppo inefficiente. Esempio di linguaggi di programmazione fra i pi\xc3\xb9 conosciuti ad utilizzare il meccanismo della garbage collection sono Java e la versione 2 di Objective-C.\n_START_SECTION_\nC++\n_START_PARAGRAPH_\nclass Point{public:_NEWLINE_   Point();              // Costruttore di default_NEWLINE_   ~Point();             // Distruttore_NEWLINE_   // ... altri metodi ...private:_NEWLINE_   int x;_NEWLINE_   int y;}\n_START_SECTION_\nC#\n_START_PARAGRAPH_\nQuesto linguaggio possiede il garbage collection rendendo poco usati i distruttori_NEWLINE_public class Punto{_NEWLINE_   private float x;_NEWLINE_   private float y;_NEWLINE_   public ~Punto()  // Distruttore_NEWLINE_   { // ... codice qui ..._NEWLINE_   }}\n_START_SECTION_\nPHP 4\n_START_PARAGRAPH_\nNella versione 4 (e precedenti) di PHP non esisteva il distruttore. Era presente una semplice gestione degli oggetti con l'uso dei costruttori.\n_START_SECTION_\nPHP 5\n_START_PARAGRAPH_\nNella versione 5 il nome della funzione deve essere __destructor_NEWLINE_class Point{_NEWLINE_   private $x;;_NEWLINE_   private $y;_NEWLINE_   public function __destructor ( )_NEWLINE_   {_NEWLINE_        // ... codice qui ..._NEWLINE_   }}"