Newsgroup: it.comp.lang.c
Titolo: [URGENTE]-Ho memory leakeage? Assegnamento puntatori a oggetti allocati staticamente

Ciao a tutti, scusate per la banalità della domanda che sto per porvi.
Se associo ad un puntatore mia_struct* una struttura allocata 
staticamente (compile time, NO malloc quindi) e successivamente associo 
a tale puntatore un'altra struttura allocata staticamente, ho uno spreco 
di memoria fin tanto che non chiudo il programma?
Ovviamente non faccio una free() della prima struttura dato che è 
allocata staticamente... :)
	ciao e grazie, rz
-- 
http://mrzac.altervista.org

 allocata staticamente... :)
ma spreco in che senso? tu vorresti liberare la memoria 
allocata dalla prima struttura (che non ti serve più) prima 
di far puntare il puntatore alla seconda? è così che lo 
intendi? se sì, alloca dinamicamente le strutture.
cmq, non è che sia un "memory leak".
ciao.

 di memoria fin tanto che non chiudo il programma?
Non capisco la domanda.
Se hai due strutture allocate staticamente non puoi avere memory leak,
casomai puoi avere un programma o un algoritmo che non fa una
buona gestione della memoria.
Siccome le strutture che dici sono entrambe statiche, esse occupano
memoria indipendentemente dal fatto che dei puntatori puntino
o meno ad esse.
ciao,
g.

 
		ciao e grazie, rz
-- 
                                   /TYDIRIUM - Ferrara - ITALY\
                                   \ICQ#    13901251   !!bye!!/
"What we're seeing with Web sites that are viewable only with IE is the
privatization of the Web."        (Mitchell Baker)

 esattamente :( . Quindi il "memory leakeage" in cosa consiste?
ad esempio in questo
char *p;
// alloco 1000 bytes e li punto con p.
p = malloc(1000);
.....
// alloco altra roba, la punto sempre con p
p = malloc(32300);
se tra le due istruzioni non ho fatto
una free(p); oppure non ho riassegnato
il puntatore ad un altro come ad esempio:
char *q;
q=p;
allora non ho piu' modo (neanche volendo)
di liberare quei 1000 bytes che avevo allocato
inizialmente, perche' per liberarli bisogna
che io sappia dove sono, e riscrivendo su p
ho perso l'unico puntatore che puntava ad essi.
ciao,
g.

 
		ciao e grazie, rz
-- 
http://mrzac.altervista.org

 variabili allocate staticamente?
Sinceramente non riesco a capire il problema. Perche'
non ti semplifichi la vita allocando la memoria dinamicamente ???
Tra l'altro, a seconda dei compilatori, allocare staticamente
grandi quantita' di memoria potrebbe essere impossibile.
E se ne allochi poca, diciamo 200Kb, allora potrebbe non essere
neanche importante liberarla prima.
Comunque il modo di liberarla c'e': la allochi staticamente
dentro la funzione nella quale ti serve.
Quando la funzione ritorna di fatto e' come se la variabile venisse
deallocata.
Cioe' se fai
int  Pippo(int n)
{
    int A[10000];
    A[1]=n;
    return n+n;
}
allora A[10000] non dovrebbe esistere al di fuori di Pippo.
ciao,
g.

 
Mi riferisco in particolare agli "oggetti" più voluminosi come possono 
essere strutture o array.
  ciao e grazie ancora, rz
-- 
http://mrzac.altervista.org

 
OK!
  ciao e grazie 1000, rz
-- 
http://mrzac.altervista.org

 serve più e può distruggerla liberando lo spazio?
Ciao,
 che io sappia, le variabili allocate "compile-time" non vanno nello stack 
... come "regola del pollice", li' ci vanno gli argomenti delle funzioni.
Comunque, indipendentemente da dove sia allocata, la risposta dipende dal
tipo di variabile. Se e' static ... perbacco, gli hai detto tu di non
cancellarla! Se non e' static, e se non e' globale (*non* usi variabili
globali, vero??? :-)), allora puo' essere solamente interna ad una 
funzione e, come ti hanno gia' detto, quando la funzione esce il 
compilatore sa che puo' riutilizzare la memoria occupata.
 Ciao
 Federico

 di memoria fin tanto che non chiudo il programma?
Semplicemente, no.
Avresti un "memory leak" nel caso in cui allocassi memoria, vi facessi 
puntare un puntatore e, assegnando al puntatore l'indirizzo di un'altra 
area di memoria, perdessi l'indirizzo dell'area allocata precedentemente.
Un "memory leak", comunque, non è automatico, nel passaggio di 
indirizzamento di un puntatore da un'area all'altra.
Nel senso che il codice seguente non produce memory leak:
char *p1, *p2;
p1 = malloc(50);
p2 = p1;
p1 = malloc(100);
free(p2);
free(p1);
L'importante è riservarsi sempre una "maniglia" per poter deallocare la 
memoria precedentemente allocata.

 serve più e può distruggerla liberando lo spazio?
Ma a che ti serve fare una cosa del genere?


Le domande che ho fatto sulle variabili allocate compile time le ho 
fatte perchè non sono un professionista, sto studiando all'università e 
non so come le cose che studio vengano realmente impiegate nel mondo del 
lavoro e della ricerca... Sono curioso e voglio migliorare.
Dalle vostre risposte ho capito bene l'argomento...
