[已解决]关于malloc申请的内存空间什么时候释放的问题

GodLordGee

在最近学习的单链表过程中，有一个问题困扰我
如果我在子函数（即除main函数以外的函数）中，使用malloc申请了一个结构体的内存空间，我们假设名字为Node；
那么，当我这个子函数运行完成以后，Node节点是否会立即自动释放？还是说我需要手动free释放？

如果Node节点不会自动释放，那是否可以说，我每一次调用子函数，都会生成一个新的Node节点，然后分配新的内存空间？
如果是这样的话，那么，当程序运行到最后，想要free掉这些Node节点应该怎么办呢？因为这个时候他们已经成了单链表，我需要一个一个节点的free释放吗？
还是说我直接把头节点free释放掉就可以了？

希望能得到大家的解答，谢谢大家。

最佳答案

月排行榜 / 总排行榜

jackz007

2021-11-22 00:03:02

       无论是在哪个函数里通过 malloc() 、realloc() 等函数分配到的内存空间都具有全局性，如果不使用 free() 进行释放，在整个程序的运行期间都会一直保持存在。
       当链表不再需要时，链表所占用的内存空间必须从头节点开始，逐一遍历每个节点，并且，用 free() 函数对本节点占用的内存进行释放，直到链表结束。

跳转到最佳答案楼层

人造人

那么，当我这个子函数运行完成以后，Node节点是否会立即自动释放？还是说我需要手动free释放？
需要手动free释放

如果Node节点不会自动释放，那是否可以说，我每一次调用子函数，都会生成一个新的Node节点，然后分配新的内存空间？
对

如果是这样的话，那么，当程序运行到最后，想要free掉这些Node节点应该怎么办呢？
把malloc返回的地址全部都保存起来，在需要释放的时候，把这些地址传给free

我需要一个一个节点的free释放吗？
对

还是说我直接把头节点free释放掉就可以了？
绝对不是这样，这样会导致内存泄漏

人造人

下面的代码你可以看一下

list.h

#ifndef _LIST_H_
#define _LIST_H_

#include <stddef.h>
#include <stdbool.h>

struct list_node_tag {
    void *data; size_t size;
    struct list_node_tag *next;
};

typedef struct {
    struct list_node_tag *head;
    size_t size;
} list_t;

list_t *list_init(void);
void list_deinit(list_t *list);
bool list_clean(list_t *list);
bool list_insert(list_t *list, size_t index, const void *data, size_t size);
bool list_delete(list_t *list, size_t index);
bool list_get(const list_t *list, size_t index, void *data, size_t size);
bool list_set(list_t *list, size_t index, const void *data, size_t size);
bool list_append(list_t *list, const void *data, size_t size);
size_t list_size(const list_t *list);
bool list_empty(const list_t *list);

#endif

list.c

#include "list.h"
#include <stdlib.h>
#include <memory.h>

list_t *list_init(void) {
    list_t *list = malloc(sizeof(*list));
    if(!list) return NULL;
    list->head = NULL;
    list->size = 0;
    return list;
}

void list_deinit(list_t *list) {
    if(!list) return;
    list_clean(list);
    free(list);
}

bool list_clean(list_t *list) {
    if(!list) return false;
    while(!list_empty(list)) list_delete(list, 0);
    return true;
}

bool list_insert(list_t *list, size_t index, const void *data, size_t size) {
    if(!list) return false;
    if(list_size(list) < index) return false;
    if(!data) return false;
    struct list_node_tag **current = &list->head;
    while(index--) current = &(*current)->next;
    struct list_node_tag *node = malloc(sizeof(*node));
    if(!node) return false;
    node->data = malloc(size);
    if(!node->data) {free(node); return false;}
    memcpy(node->data, data, size);
    node->size = size;
    node->next = *current;
    *current = node;
    ++list->size;
    return true;
}

bool list_delete(list_t *list, size_t index) {
    if(!list) return false;
    if(list_size(list) <= index) return false;
    struct list_node_tag **current = &list->head;
    while(index--) current = &(*current)->next;
    struct list_node_tag *temp = *current;
    *current = temp->next;
    free(temp->data); free(temp);
    --list->size;
    return true;
}

bool list_get(const list_t *list, size_t index, void *data, size_t size) {
    if(!list) return false;
    if(list_size(list) <= index) return false;
    if(!data) return false;
    struct list_node_tag *const *current = &list->head;
    while(index--) current = &(*current)->next;
    struct list_node_tag *temp = *current;
    if(temp->size > size) return false;
    memcpy(data, temp->data, temp->size);
    return true;
}

bool list_set(list_t *list, size_t index, const void *data, size_t size) {
    bool res = list_delete(list, index);
    return res ? list_insert(list, index, data, size) : res;
}

bool list_append(list_t *list, const void *data, size_t size) {
    if(!list) return false;
    return list_insert(list, list_size(list), data, size);
}

size_t list_size(const list_t *list) {
    if(!list) return 0;
    return list->size;
}

bool list_empty(const list_t *list) {
    if(!list) return true;
    return list_size(list) == 0;
}

jackz007

       无论是在哪个函数里通过 malloc() 、realloc() 等函数分配到的内存空间都具有全局性，如果不使用 free() 进行释放，在整个程序的运行期间都会一直保持存在。
       当链表不再需要时，链表所占用的内存空间必须从头节点开始，逐一遍历每个节点，并且，用 free() 函数对本节点占用的内存进行释放，直到链表结束。

GodLordGee

jackz007 发表于 2021-11-22 00:03
无论是在哪个函数里通过 malloc() 、realloc() 等函数分配到的内存空间都具有全局性，如果不使用 fr ...

谢谢！讲解的很清晰！