Distruttori

di il
6 risposte

Distruttori

Buongiorno,

si può parlare di distruttori in riferimento ad oggetti di tipo fondamentale? A intuito direi di no, perché se ho una classe che come campo dati ha per esempio un int* e alloca un array nella memoria libera, quando esco dal blocco in cui un oggetto di questa classe è istanziato, viene distrutto prima l'oggetto nell'heap e poi il puntatore nello stack (campo dati della classe), questo è contrario al funzionamento che avrei nel caso il campo dati della classe fosse un oggetto di tipo classe: verrebbe chiamato prima il costruttore della classe secondaria e poi quello della classe principale.

Grazie

6 Risposte

  • Re: Distruttori

    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[]?
  • Re: Distruttori

    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).
  • Re: Distruttori

    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
    In realtà non viene distrutto il puntatore p ma viene liberata la parte di stack allocata per pr.
    verrà prima chiamato il distruttore della classe secondaria e poi quello della classe principale
    E' necessario che tu chiarisca con del codice ... a occhio direi che è sbagliato, prima viene chiamato ed eseguito il distruttore della classe primaria e alla sua fine il distruttore delle classi degli oggetti contenuti.
  • Re: Distruttori

    oregon ha scritto:


    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
    In realtà non viene distrutto il puntatore p ma viene liberata la parte di stack allocata per pr.
    verrà prima chiamato il distruttore della classe secondaria e poi quello della classe principale
    E' necessario che tu chiarisca con del codice ... a occhio direi che è sbagliato, prima viene chiamato ed eseguito il distruttore della classe primaria e alla sua fine il distruttore delle classi degli oggetti contenuti.
    E il tuo occhio ci vede bene. Ho provato col codice ed effettivamente viene prima chiamato il distruttore della classe principale (per i costruttori è il contrario). Su questa cosa Domenici e Frosini hanno toppato, perché dicono chiaramente il contrario di quello che accade. Succede a tutti di sbagliare. Quindi non si pone proprio il problema della distruzione degli oggetti di tipo primitivo, dato che il comportamento è cronologicamente uguale al caso di attributo di tipo classe.
  • Re: Distruttori

    Come vedi esiste il caso delle cazz.. dei libri ... non ti fidare ...
    Se ci pensi è anche ovvio ... Se nel distruttore principale vuoi trattare i tuoi campi di altre classi, questi devono ancora esistere !

    Ma non è che parlavano di ereditarietà o di altri ambiti?
  • Re: Distruttori

    oregon ha scritto:


    Come vedi esiste il caso delle cazz.. dei libri ... non ti fidare ...
    Se ci pensi è anche ovvio ... Se nel distruttore principale vuoi trattare i tuoi campi di altre classi, questi devono ancora esistere !

    Ma non è che parlavano di ereditarietà o di altri ambiti?
    No no, cito testuale:
    per primi vengono richiamati i distruttori delle classi secondarie...
    per ultimo viene eseguito il corpo del distruttore della classe principale
    Il titolo del paragrafo è: Membri classe all'interno di classi

    No ma infatti intuitivamente non poteva essere così, perché ho ragionato con la distruzione dei tipi primitivi: se viene distrutto prima il puntatore (che corrisponde alla chiamata del costruttore della classe secondaria), il distruttore della classe (principale, perché in questo caso la classe secondaria è il tipo primitivo) non potrà distruggere l'oggetto in memoria libera, dato che non esiste più il puntatore che lo individua.
Devi accedere o registrarti per scrivere nel forum
6 risposte