Newsgroup: it.comp.lang.c
Titolo: Liberazione memoria allocata con free

Dunque , non capisco proprio come usare free() per liberare lo spazio
che ho allocato dinamicamente:
Ho una lista concatenata di elementi CELL sotto definiti:
<code>
typedef unsigned int item_t;
typedef item_t * TRANSACTION;
typedef struct CELL * LIST;
struct CELL{
        TRANSACTION t;
        LIST next;
};
</code>
Per inserire un elemento della lista uso la seguente:
<code>
void insert(TRANSACTION t,LIST *pl){
LIST tmp;
if ((*pl) == NULL) {
 (*pl) = (LIST) malloc(sizeof(struct CELL));
 (*pl)->t = t;
 (*pl)->next = NULL;
}else{
/*Inserimento in testa*/
  tmp=(*pl);
 (*pl) = (LIST) malloc(sizeof(struct CELL));
 (*pl)->t = t;
 (*pl)->next = tmp;
}
}
</code>
Per liberare la lista uso una cosa del genere:
<code>
    LIST inizio;
    LIST next = inizio
    while (inizio!=NULL) {
        next = inizio->next;
        free(inizio);
        inizio = next;
    }
</code>
Il problema e' che la free(inizio) al posto di liberarmi la cella
mi libera il puntatore alla transazione  (inizio->t).
Io vorrei liberare le celle allocate nell'insert, non i dati a cui puntano.
Grazie

 </code>
la prima volta che esegui la free(inizio) tu cerchi di liberare un'area di
memoria a caso!
LIST inizio crea un puntatore a CELL. Questo puntatore non punta da nessuna
parte, o meglio punta in un posto a caso. Devi inizializzarlo!  Dopo dici
che next deve puntare dove punta inizio, cioe' in un posto a caso anche lui!
Alla fine dici che fino a che inizio e' diverso da NULL (per ora lo e' con
grande probabilita'), allora next=inizio->next; !!!!
fare inizio->next e' ERRATO! inizio punta in una zona a caso!!!
free(inizio) idem.
inizio=next prosegui nel tuo errore cercando di andare avanti dopo essere
partito da un'area di memoria NON valida.
Tommy

 </code>
credo che andrebbe scritto
struct CELL{
        TRANSACTION t;
        struct CELL * next;
};
typedef struct CELL * LIST;
perché sennò definisci il tipo LIST senza aver definito il tipo struct CELL.

il fatto è che con
(*pl) = (LIST) malloc(sizeof(struct CELL));
te allochi memoria per la struttura struct CELL che comprende
anche l'oggetto di tipo TRANSACTION
quindi quando fai una free lui ti libera la memoria occupata dalla
struct CELL, e quindi anche per TRANSACTION
Se il puntatore all'interno di TRANSACTION lo allochi dinamicamente, quella
memoria NON viene liberata, però perdi il puntatore all'oggetto item_t, a
meno di salvarselo preventivamente, perché il puntatore fa parte di TRANSACT
ION.
Cioè viene liberata memoria per il puntatore, ma non per item_t!
Non so se sono stato spiegato!?
Ciao,
Ema

Tommy wrote:

No, no ho semplicemente trascritto male il codice (avrei sicuramente avuto
altri problemi altrimenti)
<code>
void list_destroy(LIST inizio){


 Ema
Dunque, per quanto riguarda la definizione, anch'io ero convinto bisognasse 

Io vorrei liberare le celle allocate nell'insert, non i dati a cui puntano.
Ma  se  ho  letto  bene  il puntatore e' un elemento della struttura,
quando fai una free liberi tutta la struttura e quindi perdi anche il
puntatore, ma i dati a cui punta inizio->t non vengono toccati.
Non capisco il tuo problema.
Bye
GIGI
-- 
   THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG
visit my home page:
http://web.tiscali.it/KilometroZero