[C] Liste generiche

[Frank Lioty]

Salve a tutti ragazzi (non c'è una sezione di presentazione?). Devo sviluppare un progetto per l'uni e devo scrivere delle funzioni che manipolino delle liste generiche da inserire poi in un opportuno header file.

I prototipi della funzione e le strutture della lista sono qui:

http://pastebin.com/w7HqhQbN

Le funzioni vengono poi "messe sotto stress" tramite un codice di test che cerca eventuali punti critici.

Ho implementato la New_List così:

list_t * new_List(int (* compare) (void *, void *),void* (* copyk) (void *),void* (*copyp) (void*)) {

list_t *t;
t = (list_t*)malloc(sizeof(list_t));
if (t==NULL) return NULL;

t->head = NULL;
t->compare = compare;
t->copyk = copyk;
t->copyp = copyp;

return t;

}

le funzioni passate tramite chiamata di sistema sono fornite dal professore e permettono di costruire liste con elementi aventi per chiavi interi/stringhe ed informazioni (payload) interi/stringhe.

La mia free_List:

void free_List (list_t ** pt) {

if(pt == NULL || *pt == NULL) return;
elem_t *curr = (*pt)->head;

while(curr != NULL)
{
elem_t *temp = curr;
free(curr->key);
free(curr->payload);
free(temp);
temp = (curr->next);
}
free(*pt);
*pt = NULL;

}

I problemi sorgono nel momento in cui nei test si prova a deallocare la lista in seguito ad inserimento di elementi, dandomi SIGABRT. Il debugger mi informa che l'istruzione che dà errore è quella in grassetto nella free_List. Da dire che la deallocazione di liste vuote invece non dà errori.

Altro particolare non da poco è che provando a visualizzare prima della chiamata alla free_List il contenuto della lista, questa non mi restituisce i key ed i payload dei vari elementi (ma solo puntatori a void).

Penso quindi che sia un problema di implementazione della funzione di aggiunta elemento che poi causa un errore nel momento in cui si invoca la free_List. Ecco il codice:

int add_ListElement(list_t * t,void * key, void* payload) {

if (find_ListElement(t, key) != NULL) return -1;

elem_t *new_nodo = malloc(sizeof(elem_t));
if (new_nodo == NULL) return -1;

new_nodo->key = t->copyk(key);
new_nodo->payload = t->copyp(payload);
new_nodo->next = NULL;

new_nodo->next = t->head;
t->head = new_nodo;

return 0;

}

P.S: Invoco la find_ListElement perché non sono tollerati elementi con chiavi replicate

Qualcuno sa dirmi cosa non va? Ci sto sbattendo la testa da 4 giorni ormai...

[sottovento]

Sarebbe bello vedere tutto il codice, magari con un esempio pronto per essere compilato ed eseguito.
Ad ogni modo:

void free_List (list_t ** pt) {

if(pt == NULL || *pt == NULL) return;
elem_t *curr = (*pt)->head;

while(curr != NULL)
{
elem_t *temp = curr;
free(curr->key);
free(curr->payload);
free(temp);
temp = (curr->next);
}
free(*pt);
*pt = NULL;

}

La variabile temp punta a curr. La deallochi

free(temp)

e poi la usi

temp = (curr->next);

[Frank Lioty]

Cavolo hai ragione! Ho modificato in:

    while (curr != NULL) {
	elem_t *temp = curr;
	free(curr->key);
	free(curr->payload);
	free(temp);
	curr = curr->next;

e ora SEMBRA andare...

Sarebbe bello vedere tutto il codice, magari con un esempio pronto per essere compilato ed eseguito.

Queste sono le mie implementazioni delle funzioni:

http://pastebin.com/va2DP2H2

Mentre qui trovi il file di test:

http://pastebin.com/sa4xJuhh

I test andrebbero effettuati tramite una chiamata make ad un makefile fornito dalla prof, che però non riesco a far partire. Mi sono limitato a compilare e mandare in esecuzione tramite gdb ed il programma non dà errori. Poi non so se è la stessa cosa, anche se sinceramente dubito.

[sottovento]

Originariamente inviato da Frank Lioty

Cavolo hai ragione! Ho modificato in:

    while (curr != NULL) {
	elem_t *temp = curr;
	free(curr->key);
	free(curr->payload);
	free(temp);
	curr = curr->next;

e ora SEMBRA andare...

Eh no, siamo ancora al punto di prima, perche'

curr = curr->next;

viene eseguito su un pezzo di memoria che non esiste piu'.
Dovresti spostare questa operazione in modo da eseguirla subito: memorizzi in temp il valore di curr e, fintanto che la memoria e' valida, esegui la curr = curr->next. Poi puoi deallocare il tuo elemento senza problemi

[Frank Lioty]

ok ho invertito le ultime 2 istruzioni. Visto che non ho ancora deallocato la memoria dedicata alla struct, ho ancora disponibili i puntatori all'elemento successivo, alla key e al payload (anche se questi due non puntano più ad aree di memoria visto che le ho deallocate). Quindi sposto il puntatore all'elemento successivo per poi deallocare il precedente, giusto?

Potresti dare un'occhiata al mio codice facendo partire i test? Con gdb dopo la fase di inserimento degli elementi ho messo un break per controllare che i key e i payload siano effettivamente stati "riempiti" correttamente facendo:

print lists->head->key

ma non restituisce alcun valore, semplicemente un puntatore void*, come se la memoria per il key venisse effettivamente allocata senza però inserirvi la stringa desiderata. Stesso discorso per i payload della testa e di tutti gli altri elementi...

Per la precisione l'output è questo:

(gdb) print lists->head->key
$1 = (void *) 0x804c718