Newsgroup: it.comp.lang.delphi
Titolo: Devo fare free ?

Creo una TTable a runtime e mi è venuto improvvisamente il dubbio se debba o 
no farne il free dopo l'uso. Lo devo fare o non è necessario per un 
componente TTable ? 


Dipende da cosa hai passato al costruttore della TTable e da quello che
è la logica del tuo software.
Se al costruttore hai passato nil allora è responsabilità tua
distruggere l'oggetto di tipo TTable. Generalmente dovresti includere
l'uso di tale oggetto in un try..finally, per esempio:
MyTable := TTable.Create(nil)
try
  //uso mytable qui
finally
  MyTable.Free; //lo distruggo qui
end;
Se invece al costruttore passi un owner, ad esempio Application, in quel
caso alla distruzione dell'oggetto Application (al termine del programma
in pratica) anche l'oggetto di tipo TTable verrà distrutto senza memory
leak. Esempio di costruzione con owner:
MyTable := TTable.Create(Application)
Generalmente, è buona norma controllare anche la distruzione di un oggetto.
Antonio

 ha scritto nel messaggio 
news:49ba7eaa$0$1124$4faf...@reader1.news.tin.it...


 
Usa un componente visuale (se possibile) e non ci pensi più sia alla 
creazione che alla distruzione ...
^_Goblin_^

 ragione ?
Non condivido ASSOLUTAMENTE il voler interpretare il passaggio di un
owner come escamotage per evitare di essere precisi e rigorosi
nella scrittura del codice. I motivi di questa scelta devono essere
applicativi.
La domanda giusta non è "è meglio attenersi..."
La domanda giusta è "VOGLIO CHE L'OGGETTO CHE STO CREANDO A RUNTIME
RESTI ALLOCATO FINCHE' IL SUO OWNER NON VIENE DISTRUTTO?"
Merita rispetto il fatto di aver avuto il dubbio e aver approfondito
la questione... ma trovo preoccupante il fatto che tu non conosca la
nozione basilare di owner.
A.

 nozione basilare di owner.
Non essere cosě duro, quando qui c'č qualcuno che non sa la nozione 
basilare di "semicolon". Forse crede che sia una parte del corpo.
-- 
Jax

 basilare di "semicolon". Forse crede che sia una parte del corpo.
azz...
Comunque, Jax, non è questione di essere duri.
Magari a te non è mai toccato fare selezione del personale...
Pax vobiscum.
A.

 ragione ?
Come già spiegato da Alberto, è una buona abitudine liberarsi di un 
oggetto quando non serve più averlo in memoria. Ora ne stai creando uno 
soltanto, ma se te ne servissero 1000 allora il carico dello heap 
aumenterebbe notevolmente. Delphi e FPC non sono compilatori con garbage 
collector, per cui è responsabilità del programmatore intervenire e dare 
un free quando occorre. Assegnare un owner non sempre può essere una 
buona cosa. Supponi che il live time di quell'oggetto fosse superiore a 
quello dell'owner che lo distruggerebbe quando viene liberato. Se non ti 
accorgessi di questo e nel tuo codice andassi a cercare l'oggetto 
otterresti un bell'AV.
FPC è un ottimo compilatore ed ha uno switch interessante, attivabile 
anche da Lazarus nelle Compiler Options del progetto stesso. Si chiama 
Heaptrc Unit (-gh) e al termine del programma sulla console ti segnala 
la quantità di oggetti e ram allocati e quelli distrutti, evidenziandoti 
quindi eventuali memory leaks.
Antonio

 quindi eventuali memory leaks.
bella 'sta cosa...molto carina.
Chissa xche in delphi manca....
A.


Sì, Albè, veramente interessante. Soprattutto quando inizi a spingere 
con gli opf e le classi e gli ogetti istanziati, di conseguenza, 
aumentano a dismisura.
Antonio

 Chissa xche in delphi manca....
In Delphi esiste questa funzionalitŕ, a partire dall'adozione di parte 
di FastMM come "memory manager".
Un esempio in questo articolo (vedi "Reporting Memory Leaks"):
http://edn.embarcadero.com/article/33416
Ciao,
   Marco.
-- 
MARCO BREVEGLIERI
  (
http://www.marco.breveglieri.name
)

 
http://edn.embarcadero.com/article/33416
Questa invece la segnalazione riportata in console da fpc:
-----------------
Heap dump by heaptrc unit
392 memory blocks allocated : 16156/17216
388 memory blocks freed     : 15828/16880
4 unfreed memory blocks : 328
True heap size : 589824 (128 used in System startup)
True free heap : 589088
Should be : 589136
-----------------
Antonio

 aumentano a dismisura.
Con Lazarus fate anche queste cose? Ciumbia! 
;-)
Altra domanda: io l'ho provato per sviluppare programmi per 
Windows CE, ma generava eseguibili "enormi" (15/20 Mega per una form
nuda). Poi ho abbandonato la cosa e non piů approfondito, ma la curiositŕ
mi č rimasta: era normale che la dimensione degli eseguibili fosse cosě
esagerata oppure c'era attivo di default qualche switch del compilatore
(tipo 'Includi le informazioni di Debug)?
Ciao
ACSH
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 
La seconda che hai detto :-). 
http://wiki.lazarus.freepascal.org/Lazarus_Faq#Why_are_the_generated_binaries_so_big.3F
Antonio

 ecc..) per ogni ambiente :O.
Dimenticavo di dire che qualcuno ha tentato di risolversi il problema 
semplicemente scrivendosi un nuovo framework che ridisegna e gestisce i 
controlli visuali alla stregua di come fa Delphi sotto windows. Anche la 
gestione della messaggistica è molto simile. Il framework si chiama 
fpgui ed è a cura di Graeme, membro attivo anche del progetto tiOPF. 
Attualmente compila alla grande sotto windows e linux e soprattutto alla 
stessa maniera, ovvero non devi scrivere ifdef o similari. Le 
applicazioni sono visualmente identiche sotto entrambi i sistemi ma, 
ovviamente, manca della ricchezza di componenti propria della LCL.
Antonio

 
http://wiki.lazarus.freepascal.org/Lazarus_Faq#Why_are_the_generated_binaries_so_big.3F
 
E inoltre:
http://members.chello.sk/ales/guide.html
Guarda la sezione relativa a Reducing filesize with Lazarus:
In pratica occorre attivare Smart Linking e Strip Symbols ... nelle 
Compiler Options del progetto Lazarus che si occuperà di passare questi 
switch a fpc.
Antonio

guastatore ha scritto:
<CUT>
Chiaro, grazie. 
Magari appena ho un attimo riprendo in mano Lazarus ...


 Magari appena ho un attimo riprendo in mano Lazarus ...
Ragazzi ma lo vogliamo fare un gestionale con le PALLE in lazarus o 
no???!!!
;-)
-- 
Morde


Sarebbe una cosa spettacolare :). Pensa che libertà, padrone anche della
IDE che usi per sviluppare, senza dover rincorrere continuamente nuove
versioni ecc..
@ACSH: una semplice applicazione lazarus con una form 22 Mb circa, sotto
Linux. Console: strip -s project1 riduce l'eseguibile a 4,1 Mb. upx
project1 lo porta a 1,36 mb. In proporzione, cresce pochissimo
l'eseguibile cresce molto poco visto che ha messo già tutto dentro ;).
Antonio