Newsgroup: it.comp.lang.c++
Titolo: Il Distruttore

Come si richiama il distruttore di un oggetto ? ...sě, quello che compare
come metodo
Nomeclasse::~nomemetodo()
Semplicemente con Nomeoggetto.~nomemetodo() ,   oppure quando ?
(Non infierire per il livello della domanda: sto usando C++ per caso e non
so la sintassi etc... grazie)
Davide

 wrote in message
news:jvNh7.28742$vC1.2...@news1.tin.it...

Non lo si richiama. Ci pensa il compilatore a chiamarlo quando e' opportuno.
Per oggetti non dinamici viene chiamato al termine del lifetime dell'oggetto
(normalmente al termine del suo scope e per oggetti globali o statici al termine
del prgramma).
Per oggetti dinamici viene richiamato quando fai la delete.
E' possibile richiamarlo esplicemente come hai detto tu, ma NON DEVI FARLO a
meno che non sai che cosa stai facendo. Non serve praticamente mai a meno che tu
non stia facendo qualche meccanismo speciale e specifico di gestione della
memoria. E anche in questo caso ci sono modi migliori di farlo (overload di
new/delete invece che uso di inplace new).
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

 farlo (overload di new/delete invece che uso di inplace new).
ho visto recentemente un uso del palcement new che potrebbe essere 
interessante, ma dato il mio ancora scarso senso critico non riesco a 
etichettarlo come "buono" o "cattivo" ;-).
In pratica era qualcosa del genere:
class foo {
  /* ... */
public:
  void Reset() {
        ~foo();
        new(this) foo;
  }
};
cosa ne pensate?
Ciao Anto
-- 
Antonio Cuni, 19 anni, studente
Brainbench C++ Master: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it

 cosa ne pensate?
Tutto il male possibile :-)
Scherzi a parte, questo genere di cose ha senso solo come ottimizzazioni
in parti molto di basso livello di librerie, certamente non in funzioni
chiamabili direttamente da chiunque.
 
Ciao,
Nicola

 
Ciao,
A occhio mi sembra una tecnica un po' pericolosa...
Per esempio non e' exception-safe:
Se il costruttore di foo() lancia una eccezione, ti ritrovi
in uno stato incongruente...
esempio:
class A { /*...*/ };
// il costruttore di A potrebbe fare una throw
class foo {
    A *a;
public:
    foo() { a = new A; }
    ~foo(){ delete a; }
    void reset() { ~foo(); new(this) foo; }
}
void fun() throw()
{
    try {
        foo f;
        /* ... */
        f.reset();
    } catch(...) {}
}
se A() lancia un'eccezione, il distruttore di f
viene chiamato due volte e la seconda volta viene
fatta una delete su un oggetto non allocato
quindi: undefined behaviour (nel migliore dei casi un crash)
Mettere un blocco try/catch in reset() o in foo() non sempre e'
una buona soluzione. Infatti non permetteresti ai livelli
superiori di gestire opportunamente l'eccezione.
saluti,
Fabio
-- 
Posted from [194.214.173.28] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 Tutto il male possibile :-)
bene, mi sento sollevato ;-). Era l'argomento di un thread su una ML e, in 
prima istanza, lo avevo bollato come "pericoloso". Solo che non ero 
riuscito a trovare un esempio nel quale il pericolo fosse reale, quindi si 
era giunti alla conclusione che il codice potesse anche essere passabile.
