Newsgroup: it.comp.lang.c
Titolo: corretta sequenza malloc/free

Ciao, ho dei dubbi su malloc e free.
Mettiamo che io abbia
typedef struct {
  int pippo;
  char *pluto;
} topolino;
e
topolino **minni;
magari mi sbaglio, ma cosi' facendo io ho un array (minni) di strutture
(topolino).
Magari mi sbaglio, ma per riempire minni e ogni singolo topolino dovrei
fare:
minni = malloc(n * sizeof(topolino));
minni[0] = malloc(sizeof(topolino));
topolino[0]->pluto = malloc(l * sizeof(char));
in quest'ordine. E' giusto? e per liberare il tutto basta
free(minni)
oppure devo prima fare il free di ogni singolo pluto, di ogni singolo
topolino e poi di minni?
Ah, se ho detto un sacco di boiate, correggetemi!
d

 minni = malloc(n * sizeof(topolino));
Non per come è definito 'minni'. Perché questa allocazione sia valida,
devi dichiarare:
topolino *minni;
e non:
topolino **minni;
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 free(minni)
con free(minni) credo che tu deallochi l'area che contiene i singoli 
puntatori alle struct topolino ma non deallochi le singole strutture...
secondo me devi ciclare e fare una free (minni[x]) e poi free(minni)
ma magari sbaglio.
ciao
PP

 minni è un puntatore a sizeof topolino
  minni è un puntatore a struct :) topolino
sorry :)

 puntatori sono cose ben distinte in C.
Ok, se faccio
topolino *minni
e poi 
minni = malloc(n * sizeof(topolino));
e poi
minni[0].pluto = malloc(x * sizeof(char));
poi i free devo farli per minni[0..1..2..].pluto e poi per minni oppure
mi basta liberare minni?
d

 minchiata ...
  minchiata 2 ...
   minni[0] i è un puntatore ad un puntatore ad  una struct  topolino ...
sono rimba oggi

 ciao
ecco, questo volevo sapere, grazie
d

> ecco, questo volevo sapere, grazie
si ma devi anche cambiare la allocazione

 sono rimba oggi
:-)
figurati io!

 si ma devi anche cambiare la allocazione
fatto.
d

 mi basta liberare minni?
Devi deallocare esplicitamente tutto ciò che hai allocato esplicitamente.
Non ci sono e non ci possono essere deallocazioni implicite, in C.


pier...@alice.it
 ha scritto:

Minchiata 3.
Vediamo se si può riparare alle minchiate: minni[0] non è affatto un
puntatore a puntatore. La variabile minni, così come dichiarata nel codice
di dawe non va bene, perché puntatore a puntatore. Bisogna dichiarare
minni come puntatore a strutture topolino, quindi allocare memoria per
minni e poi allocare memoria per i singoli membri pluto di ogni minni[i].
All'atto della deallocazione, bisogna deallocare il singolo membro pluto
di ogni minni[i] e poi minni.


), pero' fare il doppo puntatore
funziona lo stesso. Per curiosita', perche' scegliere un metodo
piuttosto che l'altro?
d


struct topolino{
   int pippo;
   char *pluto;
};
typedef struct topolino topolino ;
topolino **minni;
minni = malloc(n * sizeof( * topolino));
minni[0] = malloc(sizeof(topolino));
che ha che nn va ?
Andrea Laforgia ha scritto:


 che ha che nn va ?
Che non è la soluzione corretta al problema (oltre al fatto che la
sintassi è sbagliata, semmai è "minni=malloc(n*sizeof(topolino*));"). A
che pro utilizzare un doppio puntatore? basta semplicemente:
topolino *minni;
minni = malloc(n*sizeof(topolino);
minni[0].pluto = malloc(400);
minni[1].pluto = malloc(200);
...
minni[n-1].pluto = malloc(150);


 piuttosto che l'altro?
"Fare il doppio puntatore" non è una soluzione corretta al problema. 
Non si tratta di scegliere un metodo anziché l'altro, si tratta di
scegliere il metodo corretto. Un puntatore doppio può servire quando c'è
necessità di allocare mxn strutture. Non ha senso dichiarare un puntatore
doppio e poi allocare una sola struttura per ciascun puntatore; a questo
punto, si usi un puntatore singolo.


 necessità di allocare mxn strutture. 
Ok, grazie della spiegazione
d