0

我编写了一些将值存储在数组数组中的代码。我正在释放方法中释放内存，但 Valgrind 仍然报告以下内容：

==640== 
==640== HEAP SUMMARY:
==640==     in use at exit: 6,094 bytes in 33 blocks
==640==   total heap usage: 12,040 allocs, 12,007 frees, 24,146,162 bytes allocated
==640== 
==640== LEAK SUMMARY:
==640==    definitely lost: 0 bytes in 0 blocks
==640==    indirectly lost: 0 bytes in 0 blocks
==640==      possibly lost: 0 bytes in 0 blocks
==640==    still reachable: 6,094 bytes in 33 blocks
==640==         suppressed: 0 bytes in 0 blocks
==640== Rerun with --leak-check=full to see details of leaked memory
==640== 
==640== For counts of detected and suppressed errors, rerun with: -v
==640== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

我的代码如下。我首先分配一个堆并在 1 个数组中插入键。然后我有一个二维数组（数组中的数组）来保存键。插入后，我想释放内存。

我找不到这个记忆仍然活跃的地方。有人可以帮忙吗？谢谢！

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

struct hashmap
{
    int** value;
    int* key;
    int keylength;
    int x;
    int y;
};

typedef struct hashmap hashmap;

/*
hashmap* hm_initialize();
Dynamically allocates a new hashmap and returns a pointer to it.
*/
hashmap* hm_initialize()
{
    hashmap *hm = malloc(sizeof(hashmap));
    hm->value = (int**)malloc(sizeof(int*));
    hm->value[0] = (int*)malloc(sizeof(int));
    hm->value[0][0] = -999999991;
    hm->key = (int*)malloc(sizeof(int));
    hm->key[0] = -999999991;
    hm->keylength = 1;
    hm->x = 1;
    hm->y = 1;
    return hm;
};

/*
void hm_release(struct hashmap*);
Releases all memory allocated for the given hashmap.
*/
void hm_release(struct hashmap* hm)
{
    free(hm->key);
    for(int x = 0; x<hm->x;x++)
        free(hm->value[x]);
    free(hm->value);
    free(hm);
}

/*
void hm_insert(struct hashmap* hm, int key, int value);
Inserts the key-value pair to the hashmap.
*/
void hm_insert(struct hashmap* hm, int key, int value)
{
    int flagkey = 0;
    int flagvalue = 0;
    int flaglocationkey;
    int flaglocationvalue;
    int valueexists = 0;
    int counter1 = 0;

    for(int x = 0;x<hm->keylength;x++) {
        if(hm->key[x] == key) { //Old Key Exists and is Active
            flagkey = 1;
            flaglocationvalue = x;
        }
    }

    if(flagkey == 0) {
        hm->key = realloc(hm->key,(hm->keylength+1)*sizeof(int));
        hm->key[hm->keylength-1] = key;
        hm->key[hm->keylength] = -999999991;
        hm->keylength = hm->keylength + 1;
        hm->value = (int**)realloc(hm->value,(hm->x+1)*sizeof(int*));
        hm->value[hm->x] = (int*)malloc(sizeof(int));
        hm->value[hm->x][0] = -999999991;
        hm->value[hm->x-1] = (int*)realloc(hm->value[hm->x-1],2*sizeof(int));
        hm->value[hm->x-1][1] = -999999991;
        hm->value[hm->x-1][0] = value;
        hm->x++;
    }

    if(flagkey == 1) {
       printf("FOUND KEY \n");
       printf("CONTENTS OF VAL1: %d \n", hm->value[flaglocationvalue][0]);

        while((hm->value[flaglocationvalue][counter1]) != -999999991) {
            if(hm->value[flaglocationvalue][counter1] == value) {
                 printf("TRUE");
                valueexists = 1;
            }
            counter1++;
        }

        printf("CONTENTS OF VAL2: %d \n", hm->value[flaglocationvalue][counter1]);
        printf("LENGTH %d \n", counter1);

        if(valueexists == 0) {
            hm->value[flaglocationvalue] = (int*)realloc((hm->value[flaglocationvalue]),(counter1+2)*sizeof(int));
            hm->value[flaglocationvalue][counter1] = value;
             hm->value[flaglocationvalue][counter1+1] = -999999991;
        }
    }
}
4

1 回答 1

3

您发布的 Valgrind 输出表明未检测到内存泄漏：

==640==    definitely lost: 0 bytes in 0 blocks
==640==    indirectly lost: 0 bytes in 0 blocks
==640==      possibly lost: 0 bytes in 0 blocks

第四行（下面）并不意味着您泄漏了内存。这只是意味着您在退出之前没有释放所有内存。这并不构成内存泄漏，因为操作系统会在您退出时隐式释放程序分配的所有内存。

==640==    still reachable: 6,094 bytes in 33 blocks

如果您尝试测试您的 hashmap 以确保它在退出时释放所有内存，您可能忘记hm_release在退出之前调用您的函数。

于 2012-08-14T17:35:44.707 回答