如何更改我的代码（哈希表+链表）以避免内存泄漏？

Question

Sorry if the following question seems naive, I'm very new to programming and still struggle with basic concepts.

I have written a code that loads a dictionary (txt file) into a hashtable/linked list data structure, the program compiles and provides expected results, but Valgrind shows memory leaks. All major functions (creation of nodes, population, search, print) work fine, except the destroy function (one used to free memory from the mallocs). Valgrind shows memory leaks.

What am I missing here? How to make my code cleaner?

Thanks for your time! You're awesome!

I know that at least partly the reason is my approach to populating the data structure - I use 2 char* buffers (tmp and tmp1, inside and outside of the loop) to juggle inputs from fscanf into the nodes. I guess during unloading I can use the 'free' function on the outside buffer ("tmp"), but not on the inside buffer ("tmp1").

I tried using 1 buffer (both inside and outside the loops) and 2 buffers initialised statically (char tmp[]). Both methods populate the structure with just 1 word (last in the dictionary).

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// define node structure

typedef struct node
{
    char* word;
    struct node* next;
}node;

// hash size variable and hash function (thanks, K&R)

const int hash_elements = 100;

unsigned hash(char *s)
{
    unsigned hashval;
    for (hashval = 0; *s != '\0'; s++)
    hashval = *s + 31 * hashval;
    return hashval % hash_elements;
}

// function to add node to beginning of ll

int addnode_start (node** head, char* word)
{
    node* new_node = malloc(sizeof(node));
    if (new_node == NULL)
    {
        return 1;
    }
    new_node->word = word;
    new_node->next = *head;
    *head = new_node;
    return 0;
}

// function to free allocated memory

void destroy (node* hashtable)
{
    if (hashtable == NULL)
    {
        return;
    }
    else
    {
        destroy(hashtable->next);
        free(hashtable);
    }
}

// MAIN FUNCTION - puts word strings from txt files into hashtable/linked list data structures

int main (int argc, char* argv[])
{
    if (argc < 2)
    {
        printf("Usage: ./stringdll dictionary.txt\n");
        return 1;
    }

// make an array for linked lists (hashtable) and allocate memory for heads

node* hashtable[hash_elements];
for (int i = 0; i < hash_elements; i++)
{
    hashtable[i] = malloc(sizeof(node));
    if (hashtable[i] == NULL)
    {
        return 1;
    }
}

// open dictionary file for reading

char* infile = argv[1];
FILE* input = fopen(infile, "r");
if (input == NULL)
{
    printf("File does not exist.\n");
    return 1;
}

// define temporary storage for strings

char* tmp = malloc(41);

// scan file for strings and populate linked lists

while(fscanf(input, "%s", tmp) != EOF)
{
    char* tmp1 = malloc(41);
    for (int h = 0; h < hash_elements; h++)
    {
        if (hash(tmp) == h)
        {
            if (hashtable[h]->word == '\0')
            {
                hashtable[h]->word = strcpy(tmp1, tmp);
                hashtable[h]->next = NULL;
            }
            else
            {
                int tmp_0 = addnode_start(&hashtable[h], strcpy(tmp1, tmp));
                if (tmp_0 == 1)
                {
                    return 1;
                }
            }
        }
    }
}

// unload dictionary

for (int d = 0; d < hash_elements; d++)
{
    destroy (hashtable[d]);
}

return 0;

}

I expect Valgrind to show that there were no memory leaks during the work of my program.

Answer 1

Issues include

1. Your original initialization of the hash table is questionable:

    for (int i = 0; i < hash_elements; i++) { hashtable[i] = malloc(sizeof(node)); if (hashtable[i] == NULL) { return 1; } } 

   You are allocating space for nodes, but you do not populate the nodes with valid data. This allocation appears to be utterly useless. It looks like it would be not only easier but also more correct to assign NULL to the hashtable elements:

    for (int i = 0; i < hash_elements; i++) { hashtable[i] = NULL; } 

   From what I can see of your other code, I think it will even handle that without other changes.

2. It's unclear why you need to allocate space dynamically for tmp . You do not seem to do anything with it that would require dynamic allocation -- no runtime-determined length, no use outside the scope of its declaration, ... -- so it would probably be cleaner and easier to declare it as an ordinary array:

    char tmp[41]; 

   You can use that version of tmp in all the same ways you show it being used now, and you don't need to free it.

3. You dynamically allocate space for a copy of the input text, but never free it. The pointers to those spaces are initially recorded in tmp1 , and then assigned to the word members of your nodes. You do not need or want to free any value held in tmp1 , therefore, because you are still using those pointers, but your destroy() function can and should free each node's word before freeing that node.