Newsgroup: it.comp.lang.c++
Titolo: Distruttori ...

Ciao a tutti.
Premesso che č da poco che 'gioco' con il c++
vi volevo chiedere un informazione sui distruttori.
Ho scritto una classe che al suo interno definisce una  matrice
e che volevo liberare all'uscita con:
  ~NomeClasse(){delete *Matrice[];}
dove Matrice č ovviamente un dato membro della classe.
Purtroppo il compilatore ( immagino piů che giustamente ) non accetta
questa dichiarazione.
Se scrivo il distruttore vuoto
  ~NomeClasse()
non ci sono problemi, ma tutte le volte che provo ad aggiungergli un
corpo { } mi da errore, come mai? Dove sbaglio?
Grazie
Alessandro.


Per risolvere il problema dell'allocamento e del liberamento della memoria,
ti conviene dichiarare la tua matrice come membro della classe, quando
l'oggetto verrà disallocato, automaticamente la memoria occupata dai suoi
membri viene liberata. Puoi fare come segue.
(Questo è il contenuto del file header "esempio.h")
class esempio
{
    public:
        esempio();
        ~esempio();
    private:
        (dichiara qui la tua matrice)
        int matrice[10][10];
}
(Nel tuo file "esempio.cpp" avrai:)
#include "esempio.h"
esempio::esempio()
{
    inserisci qui il codice del costruttore
}
esempio::~esempio()
{
    qui non è più necessario inserire la delete di matrice
    (ti darebbe per'altro errore visto che matrice non è un puntatore)
}
In questo modo, la variabile matrice viene distrutta quando l'oggetto
esempio è disallocato.
Ciao da Packy '76

 corpo { } mi da errore, come mai? Dove sbaglio?
La deallocazione di un array dinamico (precedentemente
allocato con new) richiede l'operatore delete [] applicato
al puntatore al suo primo elemento.
La procedura esatta per deallocare un array bidimensionale
dipende da come č stato inizialmente realizzato:
(1) se utilizzi un puntatore ad array monodimensionali
(conveniente nel caso di righe di lunghezza identica, nota a compile-time),
lo allochi in questo modo (supponendo elementi interi):
int rows = 3;
const int cols = 3;
int (*Matrice)[cols] = new int[rows][cols];
e lo deallochi in quest'altro:
delete [] Matrice;
(2) Se invece impieghi un puntatore a puntatore (al tipo/classe
dei tuoi elementi che suppongo sempre interi) puoi procedere in
questa maniera per l'allocazione (per semplicitą ipotizzando
nuovamente righe di pari lunghezza):
int rows = 3;
int cols = 3;
int **Matrice = new int*[rows];
for(int i=0; i<rows; i++)
    Matrice[i] = new int[cols];
... e per la successiva deallocazione... :
for(int i=0; i<rows; i++)
    delete Matrice[i];
delete [] Matrice;
Ciao, Adriano.
____________________________________
Electronic Engineering Student
University of Tor Vergata - Rome, Italy
longd...@geocities.com

   ~NomeClasse(){delete *Matrice[];}
Come è definita Matrice?
EMG

dove Matrice è ovviamente un dato membro della classe.
Come e` dichiarata Matrice?
Se matrice e` dichiarata ad esempio
int* Matrice;
e poi
Matrice = new int[...]
allora e` delete [] matrice
se int** Matrice;
Matrice = new int* [10]
for(int i=0; i<10; ++i)
  Matrice[i] = new int[10];
allora devi dissallocare prima una dimensione e poi l'altra
nell'ordine inverso all'allocazione:
for(int i =0; i<10; ++i)
  delete [] Matrice[i];
delete [] Matrice;
Paolo
-----------------------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
-----------------------------------------------------------------

corpo { } mi da errore, come mai? Dove sbaglio?
A me funziona tutto correttamente. Che tipo di errore ti da?
Ciao, Giuseppe
---------------------------------------------------------------------------
_Guybrush su IRCNet canale #programmazione
ICQ: 42227764
---------------------------------------------------------------------------


Non posso rispondere esattamente, dato che non ho a disposizione l'intera
classe.
Me se Matrice e' un dato membro della classe, non serve deletarlo nel
distruttore:
sarebbe come cercare di deletare una variabile locale.
Se invece Matrice e' qualcosa creato con new nel costruttore, allora bisogna
mettere
il corrispondente delete nel distruttore.
Ma "delete *Matrice[]" e' molto poco probabile che sia giusto.
Se Matrice e' stato creato con qualcosa del tipo "T* Matrice = new T[n]" ,
 allora va distrutto con "delete[] Matrice"

     delete Matrice[i];
delete [] Matrice[i];
EMG

Grazie a tutti ho risolto.
Ciao
Alessandro.