valgrind告诉我，XX块中有XX个字节，肯定会丢失记录等等。
并且源代码是malloc，但是，我认为这是因为我没有为malloc释放足够的内存。无论如何，我提供了我认为导致堆错误的代码。
我知道我没有释放list_remove中的内存，我很确定这是问题的唯一来源。它可能需要一些临时转移，但我不知道这是否是唯一的问题。
list_t *list_remove(list_t *list, list_t *node) {
list_t *oldnode = node;
node->prev->next = node->next;
node->next->prev = node->prev;
if (list != oldnode) {
free(oldnode);
return list;
} else {
list_t *value = list->next == list ? NULL : list->next;
free(oldnode);
return value;
}
}
void list_free(list_t *list) {
if (list) {
while (list_remove(list, list_last(list)) != NULL) {}
}
}
list last只是给出了列表的最后一个节点。
编辑：很抱歉没有提供足够的信息，Kerrek SB，alk。这是代码的其余部分，因为你可以看到malloc出现在newnode中，我可以在那里开始创建新列表。结构很简单，有一个值和一个上一个，下一个：#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "ll.h"
struct list {
char *value;
struct list *next;
struct list *prev;
};
const char *list_node_value(list_t *node) {
return node->value;
}
list_t *list_first(list_t *list) {
return list;
}
list_t *list_last(list_t *list) {
return list->prev;
}
list_t *list_next(list_t *node) {
return node->next;
}
list_t *list_previous(list_t *node) {
return node->prev;
}
static void failed_allocation(void) {
fprintf(stderr, "Out of memory.\n");
abort();
}
static list_t *new_node(const char *value) {
list_t *node = malloc(sizeof(list_t));
if (!node) failed_allocation();
node->value = malloc(strlen(value)+1);
if (!node->value) failed_allocation();
strcpy(node->value, value);
return node;
}
list_t *list_insert_before(list_t *list, list_t *node, const char *value) {
list_t *insert_node = new_node(value);
insert_node->prev = node->prev;
insert_node->next = node;
insert_node->next->prev = insert_node;
insert_node->prev->next = insert_node;
if (list == node) {
return insert_node;
} else {
return list;
}
}
list_t *list_append(list_t *list, const char *value) {
if (list) {
(void) list_insert_before(list, list, value);
return list;
} else {
list_t *node = new_node(value);
node->prev = node->next = node;
return node;
}
}
list_t *list_prepend(list_t *list, const char *value) {
if (list) {
return list_insert_before(list, list, value);
} else {
list_t *node = new_node(value);
node->prev = node->next = node;
return node;
}
}
list_t *list_remove(list_t *list, list_t *node) {
list_t *oldnode = node;
node->prev->next = node->next;
node->next->prev = node->prev;
if (list != oldnode) {
free(oldnode);
return list;
} else {
list_t *value = list->next == list ? NULL : list->next;
free(oldnode);
return value;
}
}
void list_free(list_t *list) {
if (list) {
while (list_remove(list, list_last(list)) != NULL) {}
}
}
void list_foreach(list_t *list, void (*function)(const char*)) {
if (list) {
list_t *cur = list_first(list);
do {
function(cur->value);
cur = cur->next;
} while (cur != list_first(list));
}
}
请帮忙！它仍然在堆中给我一个内存泄漏错误...
答案 0 :(得分：4)
如果您关注list_free（），我建议你强化源代码中的删除链以下假设，当所有内容完成时，你希望* list为NULL（因为整个列表刚被删除）。 / p>
void list_free(list_t **list)
{
if (list && *list)
{
list_t* next = (*list)->next;
while (next && (next != *list))
{
list_t *tmp = next;
next = next->next;
free(tmp);
}
free(*list);
*list = NULL;
}
}
或类似的东西。通过传递外部列表指针的地址来调用：
list_t *list = NULL;
.. initialize and use your list...
// free the list
list_free(&list);
编辑 OP发布更多代码后，有些事情很明显。
list_newnode()未设置prev和next的值，因此它们包含垃圾。循环列表插入必须假设正在插入的新节点本身可以是初始列表。看起来你正在努力很多比它需要的更努力。请记住，循环列表可以将任何节点作为列表头，并且这比当前列表“head”已删除时更好。当发生这种情况时，必须是一种机制，可以将新列表'head'重新建立给调用者。同样的机制必须允许在删除最后一个节点时将列表头设置为NULL。
您的代码似乎在不使用指针指针的情况下公开尝试这样做，但它们使循环链表的任务更容易。。您在代码中注意到的其他事项：
list_prepend()和list_append()函数应被视为相对于列表头的核心插入函数。另一个apis（list_insert_before()，list_insert_after()等）应完全相对于您之前或之后插入的有效现有节点，正如我所说在上面，返回指向新插入节点的指针始终。您将看到两个非基于根的插入器函数不再通过列表头。以下是围绕您的大多数功能构建的代码表。实际的节点放置例程已经完成，我尽可能地评论它们。主测试夹具非常简单。如果这里有重大错误，我确信SO-watchtower会很快指出它们，但代码的重点不仅仅是修复你的错误;这是一个学习的东西：
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <string.h>
#include <assert.h>
// node structure
typedef struct list_t {
char *value;
struct list_t *next;
struct list_t *prev;
} list_t;
static void failed_allocation(void) {
fprintf(stderr, "Out of memory.\n");
abort();
}
// initialize a linked list header pointer. Just sets it to NULL.
void list_init(list_t** listpp)
{
if (listpp)
*listpp = NULL;
}
// return the value-field of a valid list node.
// otherwise return NULL if node is NULL.
const char *list_node_value(list_t *node)
{
return (node ? node->value : NULL);
}
// return the next pointer (which may be a self-reference)
// of a valid list_t pointer.
list_t *list_next(list_t *node)
{
return (node ? node->next : NULL);
}
// return the previous pointer (which may be a self-reference)
// of a valid list_t pointer.
list_t *list_previous(list_t *node)
{
return (node ? node->prev : NULL);
}
// return the same pointer we were passed.
list_t *list_first(list_t *headp)
{
return headp;
}
// return the previous pointer (which may be a self-reference)
// of the given list-head pointer.
list_t *list_last(list_t *headp)
{
return list_previous(headp);
}
// insert a new item at the end of the list, which means it
// becomes the item previous to the head pointer. this handles
// the case of an initially empty list, which creates the first
// node that is self-referencing.
list_t *list_append(list_t **headpp, const char* value)
{
if (!headpp) // error. must pass the address of a list_t ptr.
return NULL;
// allocate a new node.
list_t* p = malloc(sizeof(*p));
if (p == NULL)
failed_allocation();
// setup duplicate value
p->value = (value) ? strdup(value) : NULL;
// insert the node into the list. note that this
// works even when the head pointer is an initial
// self-referencing node.
if (*headpp)
{
(*headpp)->prev->next = p;
p->prev = (*headpp)->prev;
p->next = (*headpp);
(*headpp)->prev = p;
}
else
{ // no prior list. we're it. self-reference
*headpp = p;
p->next = p->prev = p;
}
return p;
}
// insert a new value into the list, returns a pointer to the
// node allocated to hold the value. this will ALWAYS update
// the given head pointer, since the new node is being prepended
// to the list and by-definition becomes the new head.
list_t *list_prepend(list_t **headpp, const char* value)
{
list_append(headpp, value);
if (!(headpp && *headpp))
return NULL;
*headpp = (*headpp)->prev;
return *headpp;
}
// insert a new node previous to the given valid node pointer.
// returns a pointer to the inserted node, or NULL on error.
list_t *list_insert_before(list_t* node, const char* value)
{
// node *must* be a valid list_t pointer.
if (!node)
return NULL;
list_prepend(&node, value);
return node;
}
// insert a new node after the given valid node pointer.
// returns a pointer to the inserted node, or NULL on error.
list_t *list_insert_after(list_t* node, const char* value)
{
// node *must* be a valid list_t pointer.
if (!node)
return NULL;
node = node->next;
list_prepend(&node, value);
return node;
}
// delete a node referenced by the node pointer parameter.
// this *can* be the root pointer, which means the root
// must be set to the next item in the list before return.
int list_remove(list_t** headpp, list_t* node)
{
// no list, empty list, or no node all return immediately.
if (!(headpp && *headpp && node))
return 1;
// validate the node is in *this* list. it may seem odd, but
// we cannot just free it if the node may be in a *different*
// list, as it could be the other list's head-ptr.
if (*headpp != node)
{
list_t *p = (*headpp)->next;
while (p != node && p != *headpp)
p = p->next;
if (p == *headpp)
return 1;
}
// isolate the node pointer by connecting surrounding links.
node->next->prev = node->prev;
node->prev->next = node->next;
// move the head pointer if it is the same node
if (*headpp == node)
*headpp = (node != node->next) ? node->next : NULL;
// finally we can delete the node.
free(node->value);
free(node);
return 0;
}
// release the entire list. the list pointer will be reset to
// NULL when this is finished.
void list_free(list_t **headpp)
{
if (!(headpp && *headpp))
return;
while (*headpp)
list_remove(headpp, *headpp);
}
// enumerate the list starting at the given node.
void list_foreach(list_t *listp, void (*function)(const char*))
{
if (listp)
{
list_t *cur = listp;
do {
function(cur->value);
cur = cur->next;
} while (cur != listp);
}
printf("\n");
}
// printer callback
void print_str(const char* value)
{
printf("%s\n", value);
}
// main entrypoint
int main(int argc, char *argv[])
{
list_t *listp;
list_init(&listp);
// insert some new entries
list_t* hello = list_append(&listp, "Hello, Bedrock!!");
assert(NULL != hello);
assert(listp == hello);
// insert Fred prior to hello. does not change the list head.
list_t* fred = list_insert_before(hello, "Fred Flintstone");
assert(NULL != fred);
assert(listp == hello);
// Hello, Bedrock!!
// Fred Flintstone
list_foreach(listp, print_str);
// insert Wilma priot to Fred. does not change the list head.
list_t* wilma = list_insert_before(fred, "Wilma Flintstone");
assert(NULL != wilma);
assert(list_next(wilma) == fred);
assert(list_previous(wilma) == hello);
// Hello, Bedrock!!
// Wilma Flintstone
// Fred Flintstone
list_foreach(listp, print_str);
list_t* barney = list_prepend(&listp, "Barney Rubble");
list_t* dino = list_insert_after(wilma, "Dino");
assert(barney != NULL);
assert(dino != NULL);
assert(listp == barney);
assert(list_previous(barney) == fred);
assert(list_next(barney) == hello);
// Barney Rubble
// Hello, Bedrock!!
// Wilma Flintstone
// Dino
// Fred Flintstone
list_foreach(listp, print_str);
// remove everyone, one at a time.
list_remove(&listp, fred); // will not relocate the list head.
// Barney Rubble
// Hello, Bedrock!!
// Wilma Flintstone
// Dino
list_foreach(listp, print_str);
list_remove(&listp, hello); // will not relocate the list head.
// Barney Rubble
// Wilma Flintstone
// Dino
list_foreach(listp, print_str);
list_remove(&listp, barney); // will relocate the list head.
// Wilma Flintstone
// Dino
list_foreach(listp, print_str);
assert(listp == wilma);
assert(list_next(wilma) == dino);
assert(list_previous(listp) == dino);
list_remove(&listp, wilma); // will relocate the list head.
// Dino
list_foreach(listp, print_str);
list_remove(&listp, dino); // will relocate the list head;
// generate a raft entries (a million of them)/
char number[32];
int i=0;
for (;i<1000000; i++)
{
sprintf(number, "%d", i);
list_append(&listp, number);
}
// now test freeing the entire list.
list_free(&listp);
return 0;
}
断言和转储是为了帮助验证算法的健全性。此结果的输出应与代码中的注释匹配：
Hello, Bedrock!!
Fred Flintstone
Hello, Bedrock!!
Wilma Flintstone
Fred Flintstone
Barney Rubble
Hello, Bedrock!!
Wilma Flintstone
Dino
Fred Flintstone
Barney Rubble
Hello, Bedrock!!
Wilma Flintstone
Dino
Barney Rubble
Wilma Flintstone
Dino
Wilma Flintstone
Dino
Dino
最后的想法：我通过valgrind运行，发现没有泄漏。 我很肯定它不会适应你的需要。**其中大部分都会（其中一半已经那里）。
答案 1 :(得分：1)
代码看起来不错。
list_t如何定义？ list_t是否有任何成员引用动态分配的内存？如果是这样，您还需要释放那些引用的内存。