Newsgroup: it.comp.lang.delphi
Titolo: Memoria non rilasciata

Ciao a tutti,
ho appena finito di sviluppare una piccola applicazione in modalit� console 
per semplificare un po' la vita prima di convertirla con interfaccia gui.
Il problema � questo, nella elaborazione dei dati faccio uso di parecchia 
memoria in particolare con array dinamici definiti come:
type
       y = record
                  ....
              end;
       x = record
                info: array of y;
                index: longword;
             end;
var z : x;
E la dimensione la definisco come:
        z.index = valore;
        setlength (z, z.index);
Tutto funziona regolarmente, la cosa strana per� � che quando termina 
l'esecuzione del programma mi sarei aspettato che la memoria precedentemente 
allocata venisse liberata, invece continua a rimanere allocata.
Ora come posso risolvere questo problema?
Probabilmente dimentico qualcosa e vi ringrazio in anticipo per il vostro 
aiuto.
Cooper. 

 aiuto.
Dimentichi che lavori su un sistema operativo al quale spetta il compito
di 
rilasciare la memoria non pi� utilizzata da un programma terminato.
Se il tuo programma non ha leak o buchi o altre menate e finisce 
regolarmente, lascia che sia lui a liberarla quando gli serve.
Ciao
ACSH
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

> memoria in particolare con array dinamici definiti come:
xche array?
A.

[...]invece continua a rimanere allocata.
Non rimane allocata. Il sistema operativo la libera ma � possibile che tu
non veda subito la deallocazione. La liberazione della memoria da parte
del sistema operativo richiede comunque un certo tempo fisiologico legato
alle sue politiche interne.



Ah capito, allora � nella normalit� pensavo ci fosse un problema da parte 
mia.  Ok grazie :) 


Nello specifico sono quelli che si adattano meglio 


[...]
Contravvengo al mio proposito iniziale di stare zitto per un po'
perchè l'argomento mi interessa.
Chiedo scusa a Cooper: se credi apro un thread apposta.
Per scrivere una applicazione che trattasse delle coordinate sul piano
cartesiano, ho dichiarato una classe definita in questo modo:
type
  Tpoint = class
    Protected
      cx, cy : Double;
      ...
Ovvero ho definito il punto come una coppia di coordinate Double.
Poi un'altra definita così:
type
  Ttsp = class
    Protected
      points : Array of Tpoint;
      function dist(a, b: Tpoint) : Double;
      ...
Per utilizzare la classe faccio una cosa del tipo:
var
  point : Tpoint;
  points : Array of Tpoint;
  ...
begin
  ...
  for i := 0 to Length(lista) do
  begin
    point := Tpoint.create(lista.x,lista.y);
    points[i] := point;
  end;
  ...
è concettualmente corretto oppure ho imboccato la strada sbagliata?
Grazie
Francesco

> Nello specifico sono quelli che si adattano meglio
cioe..??
A.


Delle semplici assegnazioni tipo:
a [x] := y
per qualcosa di cosi banale... andare a scomodare classi e liste mi sembra 
eccessivo; posso capire per qualcosa di pi� complesso ma in questa 
circostanza non mi sembra il caso.
 

 circostanza non mi sembra il caso.
Ti sbagli. L'indicizzazione di quel tipo puoi farla benissimo con una
TList e non capisco proprio perch� reputi "classi e liste" come strumenti
per fare cose "complesse". Ribadisco il consiglio: butta via quei record e
quelli array ed usa le classi e le liste.


 Poi un'altra definita cos�:
Hai provato a dare un occhio nella unit Types di delphi ... :)
[Mode OT on]
Cmq con D2010 da quello che ho visto nella VCL ormai i record sono quasi 
equiparati alle classi, in quanto si possono definire metodi anche 
dentro un record, (ma questo gi� da D2007), ma quello che vorrei capire 
sono i metodi anonimi, anche loro gi� presenti da D2009, ma estremamente 
potenziati in D2010
... prevedo che il caro "vecchietto in rosso" dovr� portare un bel peso 
nel suo sacco :)
[Mode OT off]
^_Goblin_^


Caspita! C'era gia tutto ... e anche di più. Avrei solamente dovuto
gestire l'unità di misura per avere solo interi. Grazie :)
  PPoint = ^TPoint;
  TPoint = record
    X: Longint;
    Y: Longint;
  end;
  {$NODEFINE TPoint}
  tagPOINT = TPoint;
  {$NODEFINE tagPOINT}
  PRect = ^TRect;
  TRect = record
    case Integer of
      0: (Left, Top, Right, Bottom: Longint);
      1: (TopLeft, BottomRight: TPoint);
  end;
  {$NODEFINE TRect}
  PSize = ^TSize;
  tagSIZE = record
    cx: Longint;
    cy: Longint;
  end;
  {$EXTERNALSYM tagSIZE}
  TSize = tagSIZE;
  SIZE = tagSIZE;
  {$EXTERNALSYM SIZE}
  PSmallPoint = ^TSmallPoint;
  TSmallPoint = record
    x: SmallInt;
    y: SmallInt;
  end;

> per qualcosa di cosi banale...
quindi, visto che la cosa e' "banale", e' lecito complicarsi la vita
usando gli array?
Secondo me hai le idee confuse, poi vedi tu...
A.

 ha scritto nel messaggio 
news:4617ac25-ddb3-4ed3...@k19g2000yqc.googlegroups.com...

Perch� dici cosi?
Se � vero che un linguaggio di programmazione si evolve partendo dalle cose 
pi� semplici e banali, arrivando a quelle pi� complesse... allora � anche 
vero che gli array sono stati introdotti nel linguaggio ancor prima che 
venissero introdotte le classi, oggetti e via dicendo.
Perch� quindi ritieni che l'uso degli array equivalga a complicarsi la vita? 
Se a me serve qualcosa del tipo:
         for x := 1 to 100000 do a [x] := x;
Perch� dovrei scrivere:
         a := tlist.create;
         try
           for x := 1 to 100000 do list.add (pointer (x));
         finally
           a.free;
         end;
Sostanzialmente producono lo stesso risultato con la differenza che: 
l'eseguibile prodotto nel primo caso occupa 111 kb mentre nel secondo 292 
kb;  mentre il codice nel primo caso richiede circa 60 byte nel secondo caso 
invece superiamo abbondantemente i 60 byte.
Quindi posto che abbia le idee confuse, potresti dirmi per favore dove sta 
il vantaggio del secondo caso rispetto al primo?
Io ho l'impressione (correggetemi se sbaglio) che qui passi il principio che 
bisogna usare gli oggetti a tutti i costi anche quando ci sono soluzioni 
alternative oggettivamente pi� semplici in termini di chiarezza del codice e 
dimensioni dell'eseguibile (vedi sopra).
Io posso trovare utile il ricorso alle classi se nell'ambito di un array 
dovessi eseguire operazioni di ordinamento, inserimento etc etc etc in quel 
caso li, chiaramente non ha senso inventare l'acqua calda; se c'� una classe 
che mi permette di ordinare un array o una matrice o quello che � ben venga; 
perch� in questo caso andrei a evitare di scrivere procedure e funzioni che 
svolgano quelle operazioni li dal momento che la classe gi� le prevede; ma 
quando si tratta di semplici assegnazioni il vantaggio dove sta?
Secondo me, ricorrere alle classi in questo caso specifico proprio per i 
motivi sopracitati complica e non semplifica la vita, imho.
 


Correggo:
           for x := 1 to 100000 do list.add (pointer (x));
con:
           for x := 1 to 100000 do a.add (pointer (x));
Errore di trascrizione. 

 dimensioni dell'eseguibile (vedi sopra).
Vorrei sapere su quali basi affermi che un codice basato su array e'
oggettivamente piu chiaro di uno basato su liste.
Se parli di oggettivita' devi portare dei dati. Attendo news su
questo.
A.


Ti faccio un esempio banale; la classe TLIST si trova nella unit CLASSES. 
Facciamo a meno della unit CLASSES allora sei obbligato a estrapolare tutto 
l'oggetto TLIST  e inserirlo nella tua applicazione.
A questo punto io faccio prima a usare gli strumenti forniti nativamente dal 
linguaggio e risolvere il problema con una sola riga di codice piuttosto che 
andarmi a impelagare con centinaia o migliaia di righe di codice che 
compongono l'oggetto TLIST piu altre 5-6 righe di codice per richiamarlo.
Il concetto di chiarezza del codice e dimensioni dell'eseguibile � 
strettamente legato a questo fattore.  Tu non te ne accorgi perch� includi 
la unit CLASSES nel tuo codice ma anche la unit CLASSES ha a sua volta del 
codice.
La domanda a questo punto si riduce a: PERCHE' RICORRERE AD ALTRO CODICE 
QUANDO NE POSSO FARE A MENO?
 

 quando si tratta di semplici assegnazioni il vantaggio dove sta?
A che serve assegnare se poi non devi usare?
Se sono semplici assegnazioni, crea l'array costante.


 QUANDO NE POSSO FARE A MENO?
Questa domanda equivale a: Perch� programmare, quando posso farne a meno?
Considerato come la pensi, non � una cattiva domanda.


 l'oggetto TLIST  e inserirlo nella tua applicazione.
Questo era uno scherzo, vero?
A.