sì, hai ragione, non avevo notato.

Ho provato ad implementare le altre funzioni:

codice:
int remove_ListElement(list_t * t,void * key) {

elem_t *key_element_prec;
elem_t *key_element;

key_element_prec = key_element = t->head;

/*primo elemento*/

  if (t->head->key == key) {

  t->head = t->head->next;
  /*dealloco memoria*/ 
  free(key_element);  
  return 0;

  }

/*altri elementi*/

while (key_element != NULL) {

key_element = key_element->next;

  if (key_element->key == key) {
  key_element_prec->next = key_element->next;
  free(key_element);
  return 0;
  }

key_element_prec = key_element;

}
return -1;
}
la free in questa maniera dealloca tutto correttamente? Inoltre leggevo da qualche parte che è consigliato settare a NULL quando si dealloca (facendo cioè un key_element = NULL dopo la chiamata alla free?), anche se non ho ben capito il motivo.

codice:
elem_t *find_ListElement(list_t *t, void* key) {

elem_t *current = t->head;

  while (current != NULL) {
 
  if (t->compare(current->key, key) == 0) return current;
  current = current->next;
  }

return NULL;
}
qui avrei un dubbio: non esiste un modo per creare una versione ricorsiva della find? Il mio problema è che tale funzione prende in ingresso la lista e non un elemento della lista, quindi non mi sarebbe stato possibile fare una cosa del tipo:

codice:
elem_t *find_ListElement(list_t *t, void* key) {

if (t->head == NULL ) return NULL;
if (compare(t->head ->key, key)==0) return t->head;
return find_ListElement(t->head->next , key);
}
proprio perché nel passo ricorsivo come primo parametro vuole un tipo list_t* piuttosto che un elem_t* . Devo necessariamente arrangiarmi con la versione iterativa? :master:

Mi resta da implementare la free e la new_list, con questi prototipi:

codice:
list_t * new_List(int (* compare) (void *, void *),void* (* copyk) (void *),void* (*copyp) (void*));

void free_List (list_t ** pt);
Avrei un paio di dubbi, giusto uno per ciascuna funzione :

1) perché la new_list prende come argomenti le funzioni compare, copyk e copyp? Nel momento in cui creo la lista di tipo list_t non dovrei comunque poter avere accesso alle 3 funzioni in quanto all'interno della struct di definizione?

2) perché la free prende in ingresso un puntatore ad un puntatore alla lista? Mi si ripresenta lo stesso problema della find. Avesse preso in ingresso un parametro elem_t*, potevo facilmente implementare questa versione ricorsiva (ammettendo pt il primo elemento della lista):

codice:
void free_List (elem_t* pt) {

if (pt == NULL) return;

elem_t* node = pt->next;
free(pt);
free_List(node);
}
Grazie mille per la pazienza