Newsgroup: it.comp.lang.c++
Titolo: Richiamare esplicitamente costruttore & distruttore

da un metodo della classe, mettiamo reset(), voglio che
reinizializzi la classi. Posso richiamare esplicitamente il
distruttore e poi il costruttore?? (teoricamente si.. letto
dal libro :))..
solo che in un'altro prg che avevo fatto, che richiamava un
costruttore specializzato si piantava xche' durante il
compile non venivano errori, ma in esecuzione il metodo non
veniva mai chiamato realmente... boh



Immagino che tu abbia tentato di chiamare il costruttore
in questa maniera:
  class A
  {
    public:
      A()  { /* Codice costruttore */ }
      ~A() { /* Codice distruttore */ }
      void reset
      {
        A(); // <-- Tentativo di chiamare il costruttore
      }
  };
In realta' la linea di codice indicata crea un *altro*
oggetto di tipo A e poi lo butta via. I costruttori
possono essere chiamati solo creando nuovi oggetti.
L'esempio di codice di cui hai sentito parlare e'
il seguente:
  void rebuild(A *p)
  {
    p->~A();     // Distrugge l'oggetto (ma non dealloca)
    new(p) A();  // Ricrea l'oggetto nello stesso posto
                 // utilizzando placement new
  }
Questo codice e' legale in C++ ma e' molto pericoloso
se non si comprendono esattamente tutte le implicazioni
(me ne vengono in mente immediatamente un paio: 1) la
costruzione di A potrebbe fallire e in questo caso non
esiste piu' l'oggetto vecchio e non siamo in grado di
crearne uno nuovo sul posto; 2) l'oggetto che
consideriamo potrebbe essere in realta' un oggetto
derivato da A e quindi viene rimpiazzato con qualcosa
di diverso)
Perche' hai bisogno di una porcata simile ?
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

 dal libro :))..
Si. Esempio:
  #include <new>
 
  class T {
    // ...
    void reset() {
      this->~T();
      new (this) T();
    }
  };
Pero' e' sconsigliato per vari motivi.  Uno di questi e' che non
funziona con classi derivate. Se si ha:
  class U : public T {
    // ...
  };
  U u;
  u.reset();
dopo la chiamata a reset(), u diventa un T, con ovvi problemi.
Per maggiori informazioni: GotW #22 e #23, disponibili a
http://www.peerdirect.com/resources/
	Mauro


 
http://www.peerdirect.com/resources/
Ho cominciato a leggerle e mi sembrano molto istruttive.
EMG

 derivate?
Gia', bravo, e come si estende la memoria originale dell'oggetto? Mi
sembra che vi stiate lanciando in operazioni decisamente pericolose non
si capisce bene per risparmiare che cosa; se per una classe e'
ragionevole un'operazione "reset", sarebbe bene codificarla attentamente
in modo da riportare lo stato dell'oggetto ad una condizione iniziale
ben determinata. La chiamata al distruttore di un oggetto significa la
fine della vita dell'oggetto. Se dopo e' necessario averne uno nuovo ne
si alloca un altro.
Altrimenti si definiscono due metodi privati di supporto per
inizializzare e ripulire l'oggetto, e li si chiama nel costruttore, nel
distruttore e nel metodo reset.
Il fatto che l'elasticita' del C++ permetta di farsi molto male, non mi
sembra un  motivo valido per farselo davvero.
Ciao,
Nicola

 motivo valido per farselo davvero.
ma noi siamo sadici =)
-- 
Wave++, member of EventOrizon software
http://members.xoom.it/wavexx

 si capisce bene per risparmiare che cosa;
Io comunque non me lo sognerei mai di fare cose del genere (anche perché
non le capisco molto bene).
EMG