Question

根据valgrind的说法，这个基本上初始化结构的函数是泄漏的来源：

Item* InitializeItem(char* name, int reg, char* adress)
{
    Item* i = (Item*)malloc(sizeof(Item));

    int a = strlen(name) + 1;
    int b = strlen(adress) + 1;

    i->name = (char*)malloc(a*sizeof(char));
    strcpy(i->name, name);

    i->reg = reg;

    i->adress = (char*)malloc(b*sizeof(char));
    strcpy(i->adress, adress);

    return i;
}

这是免费功能：

List* Free_List(List* list)
{
    Node* new;
    new = list->First;

    while (new != NULL)
    {
        Node* aux = new->prox;
        free(new->item->name);
        free(new->item->adress);
        free(new->item);
        free(new);
        new = aux;
    }

    free(list);
}

我尝试了一切，但我不明白发生了什么。我显然释放了一切。这是我使用--leak-check = full：

运行valgrind时收到的两个泄漏错误

41 (24 direct, 17 indirect) bytes in 1 blocks are definitely lost in loss record 5 of 6
43 (24 direct, 19 indirect) bytes in 1 blocks are definitely lost in loss record 6 of 6

这是项目结构：

typedef struct item Item;

struct item
{
    char *name;
    int reg;
    char *adress;
};

以下是列表和节点结构：

typedef struct list List;
struct list
{
    Node* node;
    Node *First, *Last;
};

typedef struct node Node;]
struct node
{
    Item* item;
    Node* prox;
};

在这里，初始化，插入和删除功能。我认为他们可能与错误有关：

List*
InitializeList()
{
    List* list = (List*)malloc(sizeof(List));

    list->First = list->Last = NULL;

    return list;
}

void
Insert(Item* student, List* list)
{
    Node* new = (Node*)malloc(sizeof(Node));
    new->prox = NULL;
    if (list->Last == NULL)
        list->First = list->Last = new;

    else
    {
        list->Last->prox = new;
        list->Last = list->Last->prox;
    }

    new->item = student;
}

Item*
Remove(List* list, int reg)
{
    Item* i = NULL;
    Node* ant = NULL;
    Node* seg = list->First;

    while (seg != NULL && seg->item->reg != reg)
    {
        ant = seg;
        seg = seg->prox;
    }

    if (seg == NULL)
    {
        i = NULL;
        return i;
    }

    if (seg == list->First && seg == list->Last)
    {
        i = seg->item;
        list->First = list->Last = NULL;
        free(seg);

        return i;
    }

    if (seg == list->Last)
    {
        i = seg->item;
        list->Last = ant;
        ant->prox = NULL;
        free(seg);

        return i;
    }

    if (seg == list->First)
    {
        i = seg->item;
        list->First = seg->prox;
        free(seg);
        return i;
    }

    else
    {
        i = seg->item;
        ant->prox = seg->prox;
        free(seg);
        return i;
    }

    free(seg);
}

这些是主要功能的最后一行。第一次调用函数Remove的地方：

Item* ret = Remove(list, 123);
ret = Remove(list, 34);
list = Free_List(list);

Answer 1

在SELECT DISTINCT user.* FROM user LEFT JOIN photo ON user.id = photo.user_id;方法中的这一行

insert

你忘记了以前列表中的内容 - ＆gt; Last;用新分配的指针替换它的值;所以以前在最后一个位置的项目永远不会被释放 - ＆gt;记忆泄漏。

Answer 2

这是因为您没有从列表中删除已删除的项目（至少根据您在问题中提出的问题）。在从列表中删除一个项目后的主函数中，您可以释放整个列表，这当然会释放列表中的所有内容，但是已从中删除的项目。

为列表中的项目添加这样的另一个函数：

void FreeItem(Item *it){
    free(it->name);
    free(it->adress);
    free(it);
}

我测试了你的代码，如下面没有内存泄漏：

Item* ret = Remove(list, 123);
ret = Remove(list, 34);
list = Free_List(list);

FreeItem(ret);

我释放了一切，但记忆正在泄漏

2 个答案: