valore non inizializzato è stato creato da uno stanziamento mucchio

Question

Sto cercando di implementare un dizionario di parole usando una tabella di hash, quindi ho bisogno di avere globale, e in uno dei miei file di intestazione ho dichiararlo

extern node** dictionary; 

Dove nodo è

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

Poi in un altro file in cui funzioni sono definite includo l'intestazione che ha la dichiarazione di dizionario, e anche io aggiungere in cima

node** dictionary; 

Poi nella funzione che carica in realtà il dizionario in primo luogo ho allocare memoria per le liste collegate che renderanno la tabella hash

bool load(const char* dict_file) 
{ 
    dictionary = malloc(sizeof(node*) * LISTS); 

    FILE* dict = fopen(dict_file, "r"); 

    if(dict == NULL) 
     return false; 

    char buffer[MAX_LEN + 2]; 

    size_dict = 0; 

    while(fgets(buffer, MAX_LEN + 2, dict) != NULL) 
    { 
     node* new_node = malloc(sizeof(node)); 

     int len = strlen(buffer); 

     new_node->word = malloc(sizeof(char) * (len)); 

     //avoid \n 
     for(int i = 0; i < len - 1; i++) 
      new_node->word[i] = buffer[i]; 

     new_node->word[len - 1] = '\0'; 

     new_node->next = NULL; 

     int index = hash(buffer); 

     new_node->next = dictionary[index]; 

     dictionary[index] = new_node; 

     size_dict++; 
    } 

    if (ferror(dict)) 
    { 
     fclose(dict); 
     return false; 
    } 

    fclose(dict); 
    return true; 
} 

Così il programma funziona bene, ho poi libera tutta la memoria allocata per archi e nodi e quando eseguo valgrind (un debugger che rileva perdite di memoria) dice che non sono possibili perdite di memoria, ma dice che c'è un errore Il valore non inizializzato è stato creato da un'allocazione dell'heap e mi reindirizza alla riga esatta in cui sono allocare memoria per dictionary la prima riga esatta della funzione di caricamento che ho scritto sopra.
Cosa sto sbagliando? Immagino che il modo in cui uso globalmente lo dictionary sia sbagliato, quindi qualcuno può suggerire un altro modo per mantenerlo globale ed evitare questo errore?

Answer 1

Nel codice aggiornato si utilizza un puntatore non inizializzato:

dictionary = malloc(sizeof(node*) * LISTS); 

// .... code that does not change dictionary[i] for any i 

new_node->next = dictionary[index]; // use uninitialized pointer 

Dato che le persone avevano già intuito, questo funziona solo se si era pre-impostare tutti i puntatori di essere NULL prima di entrare in questo ciclo:

dictionary = malloc(sizeof(node*) * LISTS); 
if (!dictionary) 
    return false; 

for (size_t i = 0; i < LISTS; ++i) 
    dictionary[i] = NULL; 

Answer 2

L'allocazione heap assegnata a dictionary utilizza malloc che non inizializza i byte restituiti. Quindi dictionary nel codice che hai postato finisce per essere una matrice di puntatori non inizializzati. Presumibilmente, continuerai a usare quei puntatori in un modo che valgrind sa essere un errore.

Un modo semplice per risolvere questo problema è utilizzare calloc anziché malloc, perché azzera i byte restituiti. In alternativa, utilizzare memset per azzerare i byte.