Newsgroup: it.comp.lang.c++
Titolo: delete this

Una classe si puo' autodistruggere?
class Suicide
{
public:
	void destroy()
	{
		delete this;
	};
};
int main()
{
	//questo codice genera un errore, segmentation fault (uso g++)
 
	//Suicide suicide;
	//suicide.destroy();
	//questo codice invece sembra essere corretto...
	Suicide *suicide;
	suicide= new Suicide;
	suicide->destroy();
}
grazie per l'attenzione!!!

Una classe si puo' autodistruggere?
si, una classe si puņ ''suicidare'' se é allocata dinamicamente
altrimenti come hai constatato, solleva un'eccezione
Antonio

 Antonio
A questo punto mi chiedo se esista un metodo per scoprire
se una classe sia stata allocata dinamicamente o no
(a parte guardarsi il codice, ovviamente...)
Cmq, grazie per la delucidazione!
lost

 se una classe sia stata allocata dinamicamente o no
Potresti sovraccaricare l'operatore new nella tua classe in modo da tenere
traccia di un'eventuale allocazione dinamica.
Marco

traccia di un'eventuale allocazione dinamica.
e tenere in una lista tutti i riferimenti alle classi allocate
dinamicamente ..... quindi interrogare a runtime quest'oggetto ...
si potrebbe fare
Antonio

 dinamicamente ..... quindi interrogare a runtime quest'oggetto ...
Anche a me sembra un'ottima idea...
Giusto per aggiungere qualcosa (programmo  pochi giorni in c++
quindi, magari sto dicendo cose gia' note a tutti) ho provato
con:
   this->Suicide::~Suicide();
e sembra funzionare ... ehm .. tranne per il fatto che
le classi allocate staticamente comunque richiamano il distruttore
all'uscita del ciclo/routine/programma... senza generare errori(?)... mah!
lost

all'uscita del ciclo/routine/programma... senza generare errori(?)... mah!
allocato dinamicamente o meno ... ciň che importa é l'istanza
dell'oggeto. il codice é sempre lo stesso, cambiano i dati nell'heap
che vengono utilizzati x far riferimento .. non penserai mica che il
compilatore ogni volta ricompili il codice per ogni oggetto della
classe ?
lui aggiunge nell'heap una nuova istanza.. se allocata dinamicamente
altrimenti la compila a buil-time nella sezione data dell'eseguibile.
non ricordo xché l'altra volta mi aveva fatto scazzare il compilatore
quando richiamavo a::metodo senza che a::metodo fosse statico ne
dichiarato .... bha!
Antonio

 tenere traccia di un'eventuale allocazione dinamica.
non e` una tecnica che funziona molto bene, come spiega Meyers nell'item 
27 di More Effective C++.
Se ho ben capito tu vorresti fare una cosa del genere:
class Prova {
        bool onHeap;
        static bool allocated_on_heap;
public:
        void* operator new(size_t s) {
                allocated_on_heap = true;
                return ::operator new(s);
        }
        Prova(): onHeap(allocated_on_heap) {
                allocated_on_heap = false;
        }
};
ho indovinato? Beh, potrebbe funzionare se allochi un singolo oggetto, 
ma come faresti in casi come questo?:
        Prova* p = new Prova[100];
        Prova* p = Prova( *new Prova);
ciao Anto
-- 
Antonio Cuni, 19 anni, studente
Brainbench C++ Master: 4.73, higher than 99% of all previous test takers.
C Language: 3.79, higher than 92% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it

 27 di More Effective C++.
Si puù scrivere codice che verifica se l'oggetto è allocato
dinamicamente. Ma è complicato e non ha senso.
In generale la tecnica del suicidio non è una buona cosa. Nei rari casi
in cui ha senso ricorrere a questa tecnica si sa a priori si che
l'oggetto è allocato dinamicamente (per esempio perchè appartiene a una
classe le cui istanze non possono essere create che dinamicamente) sia
che al momento del suicidio non c'è pendente nessun puntatore ad esso
(per esempio grazie al reference counting).
--
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