Newsgroup: it.comp.lang.c++
Titolo: Memory Leak: chi è costui?

come da oggetto... facile, no? ;-D
-- 
]\/[ad]\/[age (
www.madmagelab.cjb.net
)
"Un Maestro insegue semplicemente la sua visione di Eccellenza in
qualunque cosa sta facendo e lascia agli altri decidere se sta 
lavorando o giocando. A lui sembra sempre di fare entrambe." - Anonimo

come da oggetto... facile, no? ;-D
è quando allochi della memoria e poi non la deallochi... ovviamente il
programma cresce e cresce, come un cancro.. finché il sistema non
muore tra gli spasmi dello swap
eheheh
--
L a p o   L u c h i n i
l a p o @ l a p o . i t
w w w . l a p o . i t /

 come da oggetto... facile, no? ;-D
Immagino sia la domanda...
Come dice il nome stesso, memory leak significa una perdita, un "fuga" di 
memoria. 
In C/C++ la memoria che viene allocata dinamicamente deve essere liberata 
in modo esplicito, così come gli oggetti istanziati con new devono essere 
distrutti tramite delete. Il linguaggio non dispone di un garbage collector 
per cui gli oggetti istanziati non vengono *mai* distrutti in modo 
automatico (tranne il cleanup alla chiusura del programma, ma francamente 
non so se questo è garantito da tutti i sistemi).
Per distruggere un oggetto, il programma ha bisogno di accedervi tramite 
puntatore. Non avendo altro modo per accedervi, il programma deve fare la 
massima attenzione a non perdere mai di vista i puntatori degli oggetti 
istanziati dinamicamente.
Può capitare che per un banale errore il programma "perda di vista" un 
oggetto; può avvenire in vari modi, fra i più classici ricordo i puntatori 
locali che escono dallo scope senza che venga distrutto l'oggetto puntato o 
i puntatori che vengono sovrascritti. In questi casi gli oggetti istanziati 
rimangono appesi in memoria, senza che il programma possa sapere dove si 
trova perchè ha perso il riferimento, quindi non è più in grado di 
distruggerli e liberare la memoria occupata.
Questo è detto appunto "memory leak".
Si tratta di un bug relativamente frequente, a volte dovuto ad uno stile 
non impeccabile, a volte sottovalutato per gli effetti che non sono sempre 
e immediatamente dannosi. E' chiaro un programma che ha "vita breve" 
l'effetto può essere trascurabile, ma per un programma con un uptime 
elevato può mettere in serie difficoltà tutto il sistema.
Indipendentemente dalla "gravità" assoluta, resta indice di un programma 
scritto male. 
--
Vorrei sapere chi è il mandante di tutte le cazzate che faccio

e per evitarli basta dunque che per ogni new ci sia un delete e per
ogni malloc ci sia un free? o ci sono altri possibili memory leak più
insidiosi?


 insidiosi?
Pensa, ad esempio, ad un operator== con un'allocazione dinamica non 
rilasciata... Ogni volta che fai un banale confronto... Memory leak! 
-- 
Luc.


wrote:

tipo? esempio? ma intendi ALL'INTERNO della funzione dell'operatore?
oppure proprio che l'operatore stesso fa un'allocazione dinamica?


 oppure proprio che l'operatore stesso fa un'allocazione dinamica?
Nel corpo funzione dell'operator (qualunque operator, sono i più 
difficili da trovare)... 
-- 
Luc.

 ogni malloc ci sia un free? 
Ovviamente si, è evidente che un memory leak e dovuto a memoria non 
rilasciata quindi a un new/malloc a cui non corrisponde un free/delete.

rilasciata quindi a un new/malloc a cui non corrisponde un free/delete.
Ovviamente non si parla di "parole new/malloc" nel programma ma di
"esecuzioni new/malloc" in memoria... se crei oggetti complessi in
modo dinamico non č escluso che il ciclo che li crea sia diverso da
quello che li distrugge o finezze simili...


 devono essere distrutti tramite delete.
ad essere precisi & pignoli un memory leak e` leggermente diverso da un 
new senza delete (o malloc senza free).
In genere si parla di memory leak quando ci si "dimentica" di deallocare 
la memoria dinamica inutilizzata *e* la quantita di memoria 
"dimenticata" cresce al crescere del tempo di esecuzione.
Tanto per fare un esempio, questo non dovrebbe essere considerato un 
memory leak:
int main()
{
   int* ptr = new int[10];
}
in quanto la quantita` di memoria persa e` costante e predicibile (e 
viene in ogni caso deallocata dal sistema operativo alla chiusura del 
processo).
Ovvio che e` un pessimo stile di programmazione, ma questo e` un altro 
discorso...
ciao Anto
-- 
"Computer science is not about computers any more than astronomy
is about telescopes." -- EW Dijkstra