मैंने CS50 के लिए स्पेलर असाइनमेंट लगभग पूरा कर लिया है, लेकिन किसी कारण से, मेरी मेमोरी का एक ब्लॉक मेरे unload फंक्शन के लिए फ्री नहीं है। यहाँ मेरा कोड नीचे है:

// Implements a dictionary's functionality

#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <stdlib.h>
#include <ctype.h>

#include "dictionary.h"

// Represents a node in a hash table
typedef struct node
{
    char word[LENGTH + 1];
    struct node *next;
}
node;

// Number of buckets in hash table
const unsigned int N = 50000;

// Hash table
node *table[N];

// initialize hash table (set all values to NULL)
// reference video: https://youtu.be/2Ti5yvumFTU
void init_table()
{
    for (int i = 0; i < N; i++)
    {
        table[i] = NULL;
    }
}

// Returns true if word is in dictionary else false
bool check(const char *word)
{
    // turn all letters of word into lowercase, add NUL to indicate end of word
    // implemented from: https://cs50.stackexchange.com/questions/28984/more-help-with-speller-check
    int len = strlen(word);
    char lowerWord[len + 1];
    for (int i = 0; i < len; i++)
    {
        lowerWord[i] = tolower(word[i]);
    }
    lowerWord[len] = '\0';

    // hash the lowerWord as index, store its table[index] in node cursor
    int index = hash(lowerWord);
    node *cursor = table[index];

    // loop through linked list until the end, at NULL
    while (cursor != NULL)
    {
        if (strcasecmp(cursor->word, lowerWord) == 0)
        {
            return true;
        }
        cursor = cursor->next;
    }
    return false;
}

// Hashes word to a number
// hash function: djb2
// retrieved from http://www.cse.yorku.ca/~oz/hash.html
unsigned int hash(const char *word)
{
    unsigned int hash_value = N;
    int c;

    while ((c = *word++))
    {
        hash_value = ((hash_value << 5) + hash_value) + c; /* hash * 33 + c */
    }
    return hash_value % N;
}

// incremental int for size function
int word = 0;

// Loads dictionary into memory, returning true if successful else false
bool load(const char *dictionary)
{
    // open dictionary file, check if NULL
    FILE *dict_file = fopen(dictionary, "r");
    if (dict_file == NULL)
    {
        return false;
    }

    init_table();

    // create char array for each dictionary word (max length + nul)
    char dict_word[LENGTH + 1];

    // scan until end of file
    while (fscanf(dict_file, "%s", dict_word) != EOF)
    {
            // create a node n for each word and copy string into it
            node *n = malloc(sizeof(node));
            if (n == NULL)
            {
                return false;
            }
            strcpy(n->word, dict_word);

            // hash the word and store as index (which tells which linked list to use)
            int index = hash(n->word);

            // if table[index] is NULL, set it as node n, set next node as NULL
            if (table[index] == NULL)
            {
                table[index] = n;
                n->next = NULL;
            }
            // otherwise set next node as table[index], table[index] as current node n
            else
            {
                n->next = table[index];
                table[index] = n;
            }
            word++;
    }
    size();
    return true;
}

// Returns number of words in dictionary if loaded else 0 if not yet loaded
unsigned int size(void)
{
    return word;
}

// Unloads dictionary from memory, returning true if successful else false
bool unload(void)
{
    for (int i = 0; i < N; i++)
    {
        node *cursor = table[i];
        while (cursor != NULL)
        {
            node *temp = cursor;
            cursor = cursor->next;
            free(temp);
        }
    }
    return true;
}

जब मैं आउटपुट की जांच करने के लिए वालग्रिंड चलाता हूं (इस इनपुट का उपयोग करके: help50 valgrind ./speller texts/cat.txt), मैं देखता हूं कि 552 bytes in 1 blocks अभी भी पहुंच योग्य हैं और मेरा कुल ढेर उपयोग 143,096 allocs, 143,095 frees है। यह पूर्ण वालग्रिंड आउटपुट है:

==27463== Memcheck, a memory error detector
==27463== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==27463== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==27463== Command: ./speller texts/cat.txt
==27463== 

MISSPELLED WORDS


WORDS MISSPELLED:     0
WORDS IN DICTIONARY:  143091
WORDS IN TEXT:        6
TIME IN load:         1.28
TIME IN check:        0.00
TIME IN size:         0.00
TIME IN unload:       0.18
TIME IN TOTAL:        1.46

==27463== 
==27463== HEAP SUMMARY:
==27463==     in use at exit: 552 bytes in 1 blocks
==27463==   total heap usage: 143,096 allocs, 143,095 frees, 8,023,416 bytes allocated
==27463== 
==27463== 552 bytes in 1 blocks are still reachable in loss record 1 of 1
==27463==    at 0x4C2FB0F: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==27463==    by 0x5258E49: __fopen_internal (iofopen.c:65)
==27463==    by 0x5258E49: fopen@@GLIBC_2.2.5 (iofopen.c:89)
==27463==    by 0x40126E: load (dictionary.c:87)
==27463==    by 0x4009B4: main (speller.c:40)
==27463== 
==27463== LEAK SUMMARY:
==27463==    definitely lost: 0 bytes in 0 blocks
==27463==    indirectly lost: 0 bytes in 0 blocks
==27463==      possibly lost: 0 bytes in 0 blocks
==27463==    still reachable: 552 bytes in 1 blocks
==27463==         suppressed: 0 bytes in 0 blocks
==27463== 
==27463== For counts of detected and suppressed errors, rerun with: -v
==27463== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
0
qwert9988 15 जून 2020, 06:38

1 उत्तर

सबसे बढ़िया उत्तर

load फ़ंक्शन के अंत में कोड में एक fclose(dict_file) नहीं है।

1
kaylum 15 जून 2020, 03:46