c - 我释放了一切，但内存正在泄漏

根据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);
}

我什么都试过了，但我不明白发生了什么很明显我解放了一切。
以下是我在运行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);

最佳答案

在insert方法的这一行中：

list->Last = list->Last->prox;

您将失去对list->Last中先前内容的跟踪；将其值替换为新分配的指针；这样以前位于最后位置的项将永远不会被释放-->内存泄漏。

关于c - 我释放了一切，但内存正在泄漏，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/32834913/