migliorabile ha scritto:
Ni,
1) no, nel senso che i tipi primitivi non prevedno un distruttore, cioe' un metodo chiamato quando l'oggetto viene deallocato
2) si, nel senso che puoi immaginare la presenza comunque di un distruttore, che, semplicemente, non fa nulla.
ATTENZIONE, Il tuo esempio e' SBAGLIATO:
a parte il fatto che parli di distruttore e poi fai un esempio con il costruttore (esempio, anche questo, sbagliato, perche' l'operazione e' esattamente al contrario)
se la tua classe ha un membro (diciamo pv]) di tipo int*, il distrutore della classe NON DEALLOCA l'oggetto puntato da pv. Lo devi fare tu!
Infatti, se tu non inizializzi esplicitamente, pv puo' assumere un qualunque valore.
Se si dovesse tentare deallocare la memoria puntato da questo puntatore, sai che botto!
E poi lo dovresti deallocare con la free, con la delete o con la delete[]?
No quello di scrivere costruttore è stato un lapsus, volevo dire distruttore, naturalmente. E comunque il comportamento, secondo il Domenici Frosini, è questo: vengono prima chiamati i distruttori delle classi secondarie e poi quello della classe principale (anche per i costruttori vale la stessa cosa). Può essere che ci sia un errore nel libro, proverò col debugger a vedere che succede.
Comunque intendevo dire che, se in una classe Prova ho un campo dati:
int* p;
e nel costruttore Prova(int n) di questa classe faccio:
p = new int(n);
e nel distruttore scrivo:
delete p;
succede che, per forza di cose, all'uscita dal blocco in cui definisco:
Prova pr(5);
verrà prima chiamato il distruttore di Prova che distrugge l'intero in memoria libera (che ha valore 5) e poi verrà distrutto il puntatore p nello stack, altrimenti, se così non fosse, il distruttore non saprebbe cosa distruggere. Invece il comportamento che si ha quando metto un oggetto di tipo classe come campo dati è che, all'uscita dal blocco, verrà prima chiamato il distruttore della classe secondaria e poi quello della classe principale (almeno, ripeto, secondo il Domenici Frosini).