Distruttore (informatica)

Da Wikipedia, l'enciclopedia libera.

I distruttori, in informatica e specificamente nella programmazione orientata agli oggetti, sono degli eventi particolari che viene invocato automaticamente quando l'oggetto viene distrutto.
Sono stati concepiti per liberare le risorse utilizzate dall'oggetto, definite dalla loro classe e create dal corrispondente costruttore ed eventualmente le altre risorse allocate dinamicamente durante l'esecuzione dei metodi dell'oggetto stesso.

Uso[modifica | modifica sorgente]

Nella 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.

Il distruttore, a differenza del costruttore, non può accettare nessun tipo di parametro, perché se non chiamato esplicitamente, sarà il compilatore a inserire a fine programma la chiamata al distruttore. Per questo motivo, per ogni classe può esserci un solo distruttore, rendendo impossibile l'overloading.

ATTENZIONE: non è obbligatorio che un distruttore sia dichiarato public! L'esempio:

class A {int i;
       ~A() {} 
public: A(int v) {i=v;} 
};
 
int main(int argc, char* argv[])
{
  A *a = new A(2); // ok
  // A b(1);  <----- non ammesso perché il distruttore è privato (error C2248: 'A::~A' : cannot access private member declared in class 'A')
}

compila perfettamente ma impedisce che un oggetto di classe A venga istanziato sullo stack ma consente che venga instaziato sullo heap. È ovvio tuttavia che un metodo di distruzione debba essere fornito all'utente il quale, a questo punto, può accettare anche dei parametri e tornare dei valori. Esempio:

class A {int i;
static int count;
                ~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[])
{
  A *a = new A(2);
  bool b = A::Delete (a);// b=1
  b = A::Delete (a);     // b=0
}

Linguaggi garbage collected[modifica | modifica sorgente]

Nei linguaggi che mettono a disposizione un garbage collector, il distruttore è spesso inutile in quanto le risorse occupate da un oggetto vengono automaticamente liberate nel momento in cui non c'è più nessun riferimento all'oggetto stesso. In questi linguaggi è 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ù conosciuti ad utilizzare il meccanismo della garbage collection sono Java e la versione 2 di Objective-C.

Linguaggi di programmazione[modifica | modifica sorgente]

C++[modifica | modifica sorgente]

class Point
{
public:
   Point();              // Costruttore di default
   ~Point();             // Distruttore
   // ... altri metodi ...
private:
   int x;
   int y;
}

C#[modifica | modifica sorgente]

Questo linguaggio possiede il garbage collection rendendo poco usati i distruttori

public class Punto
{
   private float x;
   private float y;
   public ~Punto()  // Distruttore
   { // ... codice qui ...
   }
}

PHP[modifica | modifica sorgente]

PHP 4[modifica | modifica sorgente]

Nella versione 4 (e precedenti) di PHP non esisteva il distruttore. Era presente una semplice gestione degli oggetti con l'uso dei costruttori.

PHP 5[modifica | modifica sorgente]

Nella versione 5 il nome della funzione deve essere __destructor

class Point
{
   private $x;
   private $y;
   public function __destructor ( )
   {
        // ... codice qui ...
   }
}

Voci correlate[modifica | modifica sorgente]

informatica Portale Informatica: accedi alle voci di Wikipedia che trattano di informatica