Newsgroup: it.comp.programmare.win32
Titolo: AIUTO! puntatori ad oggetti inesistenti!

Ciao!
Che test devo effettuare su di un puntatore ad un oggetto per sapere se 
l'oggetto a cui esso punta esiste ancora o è stato distrutto?
Grazie!



Generalmente e` buona norma porre i puntatori ad un valore prestabilito
(nil in pascal, NULL in C, 0 in C++) quando questi non puntano piu` ad
un oggetto non valido. In generale si tratta di una operazione affidata
al programmatore.
Paolo
-----------------------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
-----------------------------------------------------------------

 l'oggetto a cui esso punta esiste ancora o è stato distrutto?
La fortuna :-)
In realtà penso non esista un test. Bisognerebbe trovare un modo per andare
a colpo sicuro.
--
Stefano Pettini
domi...@tiscalinet.it
web.tiscalinet.it/dominion
ICQ#: 38328322

 a colpo sicuro.
In COM il problema viene "risolto" introducendo delle ferree regole
sul reference counting.
Si potrebbe usare una tecnica simile, oppure implementare una
classe di smart pointers e adottare la convenzione di usare
solo gli smart pointers per accedere a tutte le istanze di un oggetto.
Sent via Deja.com 
http://www.deja.com/
Share what you know. Learn what you don't.

Grazie!
Se la classe l'hai fatta tu (o puoi modificarla...) prova a fare in modo che
all'esecuzione della funzione distruttore venga settato (magari a NULL) il
valore del puntatore...anche se magari sara un po macchinoso e incasinato
dovrebbe fungere!
Ciao by Tdx

l'oggetto a cui esso punta esiste ancora o è stato distrutto?
Non esiste modo. Devi essere tu a tenere traccia della creazione e
cancellazione degli oggetti, e fare in modo di non utilizzare un
puntatore ad un oggetto inesistente.
Topoldo
(Grazie a Dio, sono ateo)

 wrote in message
news:37e87ef...@news.tin.it...

Sostanzialmente giusto. In Win32, peró, c'é anche l'API IsBadWritePtr
(e simili) per controllare se il tuo processo ha accesso in lettura,
scrittura, esecuzione, ecc, all'area di memoria, di una certa dimensione,
indicata da un certo puntatore; a volte, queste API (o l'effetto del
tutto equivalente che si puó ottenere con uso opportuno delle varie
strutture SEH di Win32) permettono di "tenere d'occhio" (sino ad un
certo punto!) i puntatori.
Non é un approccio affidabile quello di contare su queste API per
sapere se un dato oggetto esiste ancora:
    -- l'oggetto potrebbe essere stato distrutto, ma la memoria
        che occupava essere ancora accessibile (ad esempio tenuta
        da parte dall'heap manager);
    -- l'oggetto potrebbe essere stato distrutto, e un altro oggetto,
        piú tardi, costruito nella stessa zona di memoria.
Senza dubbio, l'ideale sarebbe avere pieno controllo di cosa
succede ai propri puntatori.  Ma ció non é sempre possibile,
perché al giorno d'oggi si va sempre di piú verso la programmazione
"per componenti", cosa ottima per tanti versi ma incompatibile col
concetto di "pieno controllo", poiché l'applicazione che "io" scrivo
contiene sempre, in realtá, tantissimo codice scritto da altri e non
sotto il mio controllo.  In queste condizioni, un poco di paranoia
sull'uso dei puntatori, a volte, non guasta, cosí, quando l'utente dei
componenti che io scrivo ha combinato qualche casino, io posso
almeno diagnosticare il problema con precisione, per esempio
tornando un codice di errore E_POINTER se e quando il "caro"
utente passa dei puntatori marci ai metodi delle mie classi COM.
E le IsBadWritePtr &c (e piú in generale l'SEH) aiutano molto se
e quando si vogliono fare questo tipo di controlli.
Fra i vari altri "trucchi" importanti per questo tipo di controlli,
c'é anche quello classico di avere, a un offset noto dell'oggetto,
una "signature" (32 bit che devono sempre avere un dato valore
ben preciso, inizializzati a quel valore nel ctor, con quel valore
che viene invertito nel dtor); questa permette di fare controlli
piú dettagliati e puntuali, e, in accoppiata con il SEH, si resta
vulnerabili al solo problema dell'oggetto distrutto e ricostruito
allo stesso posto (e a questo in generale non c'é difesa: il
puntatore che si esamina é in questi casi, in effetti, del tutto
valido, a un oggetto del tipo giusto, ecc ecc, vai un po' a capire
che sono successi casini "auto-mascherantisi" nella zona...:-).
Alex