what is wrong with this flushing function for hash table? - c

Question

I have a weird problem with flushing the entire hash-table.
Data structures are as below:
typedef struct data_entry_{
char data[32];
struct data_entry_ *next;
}data_entry_t;
typedef struct table_entry_{
char hash[32];
struct data_entry_ *next_data;
struct table_entry_ *next_hash;
}table_entry_t;
typedef struct table_{
table_entry_t *next;
}table_t;
In main function, I initialize the table with below function
table_t *init(){
table_t *table = calloc(1, sizeof(table_t));
table_entry_t *node = calloc(1, sizeof(table_entry_t));
node->next_hash = NULL;
node->next_data = NULL;
strcpy(node->hash, "NULL");
table->next = node;
return table;
}
Add data to the table with below function:
int add(table_t *table, char *data){
table_entry_t *head = table->next;
table_entry_t *prev;
char hash[32];
hash_function(data, hash);
if(!strcmp(head->hash, "NULL")){
data_entry_t *item = calloc(1, sizeof(data_entry_t));
strcpy(item->data, data);
item->next = NULL;
strcpy(head->hash, hash);
head->next_data = item;
head->next_hash = NULL;
return 0;
}
while(head){
if(!strcmp(head->hash, hash)){
data_entry_t *temp = head->next_data;
data_entry_t *previous;
while(temp){
if(!strcmp(temp->data, data)){
printf("data exists\n");
return 0;
}
previous = temp;
temp = temp->next;
}
data_entry_t *item = calloc(1, sizeof(data_entry_t));
strcpy(item->data, data);
item->next = NULL;
previous->next = item;
return 0;
}
prev = head;
head = head->next_hash;
}
table_entry_t *pack = calloc(1, sizeof(table_entry_t));
data_entry_t *item = calloc(1, sizeof(data_entry_t));
strcpy(pack->hash, hash);
strcpy(item->data, data);
item->next = NULL;
pack->next_data = item;
prev->next_hash = pack;
return 0;
}
And the problem is with this function:
int flush(table_t *table){
table_entry_t *head = table->next;
table_entry_t *temp;
data_entry_t *current, *previous;
if(head->next_data == NULL){
printf("table is empty\n");
return -1;
}
strcpy(head->hash, "NULL");
while(head){
current = head->next_data;
while(current){
previous = current;
current = current->next;
free(previous);
}
temp = head;
head = head->next_hash;
free(temp);
}
return 0;
}
after calling flush, when I wanna show the table, I expect to see "table is empty" but apparently this function does not free any nodes. I really appreciate if anyone help me.

Answer 1

You expect that a pointer which got freed gets the value NULL.
That however is impossible, because free() only receives the value inside the pointer, not the address, i.e. not pointer to the pointer.
Your code assumes that a freed pointer is NULL here:
if(head->next_data == NULL){
That however will only be the case if you write the NULL value to the pointer.
There is some code which seems similar, strcpy(head->hash, "NULL");, but I trust that you do not expect that to write the non-string value NULL to the pointer.
You can make sure that all pointer which you free afterwards contain NULL, by writing it yourself. Near this free(previous);. It is however necessary to write NULl to the actual pointer in the linked list - and not e.g. to the variable previous. You can use the copy of the pointer stored in that variable to free, but not for overwriting the original.