调用free()后未释放内存 [英] Memory not freed after calling free()

问题描述

我有一个简短的程序，该程序通过向其添加节点来生成链表，然后释放由链表分配的内存.

I have a short program that generates a linked list by adding nodes to it, then frees the memory allocated by the linked list.

Valgrind不会报告任何内存泄漏错误，但是该过程将继续保留分配的内存.

Valgrind does not report any memory leak errors, but the process continues to hold the allocated memory.

仅在将分配的内存从sizeof(structure_name)更改为固定数字512后，我才能修复该错误.(请参见注释的代码)

I was only able to fix the error after I changed the memory allocated from sizeof(structure_name) to fixed number 512. (see commented code)

这是错误还是正常操作? 这是代码:

Is this a bug or normal operation? Here is the code:

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


typedef struct llist_node {
  int ibody;
  struct llist_node * next;
  struct llist_node * previous;
  struct llist * list;
}llist_node;

typedef struct  llist {
  struct llist_node * head;
  struct llist_node * tail;
  int id;
  int count;
}llist;

llist_node * new_lnode (void) {
  llist_node * nnode = (llist_node *) malloc ( 512 );
  //  llist_node * nnode = (llist_node *) malloc ( sizeof(llist_node) );
  nnode->next = NULL;
  nnode->previous = NULL;
  nnode->list = NULL;
  return nnode;
}

llist * new_llist (void) {
  llist * nlist = (llist *) malloc ( 512 );
  //  llist * nlist = (llist *) malloc ( sizeof(llist) );
  nlist->head = NULL;
  nlist->tail = NULL;
  nlist->count = 0;
  return nlist;
}

void add_int_tail ( int ibody, llist * list ) {
  llist_node * nnode = new_lnode();
  nnode->ibody = ibody;
  list->count++;
  nnode->next = NULL;
  if ( list->head == NULL ) {
    list->head = nnode;
    list->tail = nnode;
  }
  else {
    nnode->previous = list->tail;
    list->tail->next = nnode;
    list->tail = nnode;
  }
}

void destroy_list_nodes ( llist_node * nodes ) {
  llist_node * llnp = NULL;
  llist_node * llnpnext = NULL;
  llist_node * llnp2 = NULL;
  if ( nodes == NULL )
    return;
  for ( llnp = nodes; llnp != NULL; llnp = llnpnext ) {
    llnpnext = llnp->next;
    free (llnp);
  }
  return;
}

void destroy_list ( llist * list ) {
  destroy_list_nodes ( list->head );
  free (list);
}

int main () {
  int i = 0;
  int j = 0;
  llist * list = new_llist ();

  for ( i = 0; i < 100; i++ ) {
    for ( j = 0; j < 100; j++ ) {
      add_int_tail ( i+j, list );
    }
  }
  printf("enter to continue and free memory...");
  getchar();
  destroy_list ( list );
  printf("memory freed. enter to exit...");
  getchar();
  printf( "\n");
  return 0;
}

推荐答案

如果通过该进程继续保留分配的内存"，则表示ps没有报告该进程的内存使用量减少，这是完全正常的.由于种种原因，将内存返回到进程的堆并不一定会使该进程将其返回到操作系统.如果您在一个大循环中一次又一次地创建和销毁列表，并且进程的内存使用没有无限增长，那么您可能没有真正的内存泄漏.

If by "the process continues to hold the allocated memory" you mean that ps doesn't report a decrease in the process's memory usage, that's perfectly normal. Returning memory to your process's heap doesn't necessarily make the process return it to the operating system, for all sorts of reasons. If you create and destroy your list over and over again, in a big loop, and the memory usage of your process doesn't grow without limit, then you probably haven't got a real memory leak.

[再次编辑以添加:顺便说一下，分配512字节块使问题消失的最可能原因是，您的malloc实现以某种方式特别对待较大的块，使它在出现时更容易注意到是不再使用的整个页面-如果要将所有内存返回给操作系统，这是必需的.]

这篇关于调用free()后未释放内存的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！