Newsgroup: it.comp.lang.c
Titolo: Re: Allocazione dinamica della memoria: malloc() e free()

 liberare tale memoria.
..EEEEEEEEEEEEEEH ?
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

Ciao a tutti, volevo chiedervi se è un modo corretto di operare allocare
all'interno di una funzione, chiamata all'interno del main(), della
memoria e associarla ad un puntatore pt2 idoneo su cui si opera in tale
funzione; la funzione ritorna tale puntatore (quindi l'indirizzo della
memoria allocata) e nel main() si associa ad un puntatore idoneo pt1 
tale indirizzo chiamando, infine, un free(pt1) quando si desidera 
liberare tale memoria.
	ciao e grazie anticipatamente per le risposte, rz
-- 
"Una riga lasciata bianca può valere più di 100 parole"

 
Intendevo dire:
-chiamo da main() una funzione
-tale funzione alloca un'area di memoria e la associa a pt1 (puntatore 
idoneo creato nella funzione)
-la funzione ritorna tale puntatore
-nel main() uso il valore di ritorno per associarlo ad un puntatore pt2 
idoneo
-alla fine del main() faccio un free(pt2)
Per funzionare funziona ma è una procedura pulita e corretta?
	ciao, rz
-- 
http://mrzac.altervista.org

 Per funzionare funziona ma è una procedura pulita e corretta?
Corretta si`. Ricorda che, fatta la free, non devi accedere all'area
di memoria ne' con pt2, ne' con pt1, altrimenti avrai con buona
probabilita` un crash.
Pulita? Non ha molto senso chiederselo: dipende da quello che
si deve fare, ma plausibilmente e` _anche_ pulita. Per esempio,
potresti "programmare ad oggetti" in C usando un meccanismo simile
a quello che proponi:
myclass_t * new_myclass_obj(void);
void free_myclass_obj(myclass_t *);
int main (int argc, char * argv[])
{
     myclass_t * pt2;
     pt2 = new_myclass_obj();
     :
     free_myclass_obj(pt2);
}
dove myclass_t e` un tipo definito con typedef che indica la
classe, new_myclass_obj() e` la funzione che alloca memoria
e la restituisce (esattamente quello che fa la tua funzione)
mentre free_myclass_obj() esegue al suo interno una free()
sul puntatore passato.
Spero di essere stato chiaro.
Saluti,
Marco
-- 
To email me, remove the no_ and _spam from my address.

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

 fine main() un segmentation fault?
forse perche' non stai liberando memoria che hai allocatu tu
(come quando fai free(temp);)
bensi' un puntatore che punta alle variabili di ambiente e quella non
e' memoria gestita da te.
Per lo stesso motivo (a meno che tu non sia un esperto), eviterei
di scrivere nella zona di memoria puntata da pwdir, ma preferire
copiarmi la stringa in un mio array.
ciao,
g.

  pwdir = getenv("PWD");
Qui sovrascrivi il precedente valore con quello restituito da 'getenv', che
*non* può essere passato a 'free', perché non è stato restituito da
'malloc'/'calloc'. (Per inciso, sovrascrivendo il valore, perdi anche
l'unico riferimento che avevi alla memoria allocata, che quindi non potrà
essere rilasciata.)
Max



Esattamente. Aggiungo due note:
1) allocando memoria per pwdir, crei un memory leak, perche' poi
    assegni a pwdir il puntatore restituito da getenv(): cosi` perdi
    l'indirizzo della memoria che avevi allocato.
2) PROMPTLEN non so come lo hai calcolato, ma ogni sistema (Unix) puo`
    definirsi le lunghezze massime dei percorsi come gli pare e piace.
    Al volo, pero`, non ricordo come si ottiene questo valore.
Inoltre vorrei ben capire cosa dovrebbe fare la funzione dir_crnt():
tu vuoi che dal pathcorrente estragga l'ultima directory? Per esempio,
vuoi che da
   "/questa/e/la/mia/directory"
ritorni
  "directory"
e che da
  "/"
ritorni
  "/"?
In tal caso, temo che non funzioni, indipendentemente dal seg fault.
Capiamo perche' sull'esempio di cui sopra.
pwdir prende il valore "/questa/e/la/mia/directory" e lungz il valore 26.
Allochi spazio a temp e j diventa 26. Dopo il ciclo for, i e` 9, j e` 16
mentre temp contiene questo valore:
   "\0yrotcerid/"
Andiamo avanti: j e lungz assumono il valore 8 (== i-1). Alla fine del
secondo ciclo, abbiamo una cosa decisamente non voluta. pwdir (al di la`
del fatto che non dovresti scriverci) contiene:
   "irectory\0"
Se vuoi fare quello che suppongo io, propongo questa soluzione tra le
infinite possibili. Faccio notare che l'unico caso in cui PWD ha uno
slash come ultimo carattere e` quando PWD e` esattamente "/".
Sottolineo anche che non faro` controlli sugli errori e che la funzione
non l'ho ne' compilata, ne' tantomeno testata.
char * dir_crnt()
{
   char * temp;
   char * pwdir;
   int len;
   int start;
   pwdir = getenv("PWD");
   len = strlen(pwdir);
   /* Trovo l'indice dell'ultimo '/' in pwdir */
   start = (int) (strrchr(pwdir, '/') - pwdir);
   temp = calloc(len - start + 1, sizeof(char));
   /* Copia da pwdir a temp e ritorna temp */A
   return memcpy(temp, pwdir + start, len - start);
}
Se vuoi pure sovrascrivere la variabile d'ambiente PWD con quello
che hai ricavato in questa funzione, allora prima di eseguire
   return memcpy(temp, pwdir + start, len - start);
metti un bel
   setenv("PWD", temp, 1);
Nota che in questo caso e` molto probabile che PWD rappresenti
una directory inesistente.


 g.


 
	grazie infinitamente per la disponibilità, rz
-- 
http://mrzac.altervista.org

 tutte le directory in cui l'ho provata, pure da "/".
E` possibile che tu abbia ragione: non ho provato il codice ma l'ho fatto
girare a mente. Cmq guardati la mia proposta di soluzione: mi sembra piu`
leggibile e comprensibile.
Spero nuovamente di essere stato chiaro.
Saluti,
Marco
-- 
