valgrind告诉我，我在xx块中有xx字节肯定会丢失记录blah blah blah
，源位于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) {}
}
}
列表最后一个简单地给出了列表的最后一个节点。
编辑：很抱歉没有提供足够的信息，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));
}
}
请帮忙！它仍然给我带来内存泄漏错误...
如果您关注list_free（），建议您在源删除链中，以下假设，当所有内容完成后，您希望 *列表为null（因为整个列表刚刚删除）。
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);
edit OP发布了更多代码后，几件事都在眩光。
-
list_newnode()不设置prev和next的值，因此它们包含垃圾。 - 这里的每个其他功能都假设（1）在接下来并正确地初始化。坦率地说，我很惊讶这并不是第二次添加的错误。
圆形列表插入必须假定要插入的新节点可以是初始列表本身。看来您正在做这项努力比需要的要困难得多。请记住，一个圆形列表可以将任何任何节点作为列表头，这证明没有比当前列表"头" 删除更好。必须是一种机制，可以在发生这种情况时向呼叫者重建新列表"头"。当删除最后一个节点时，相同的机制必须必须允许将列表头设置为null。
您的代码似乎无需使用指针来指针而做出明显的尝试，但是它们使循环链接列表的任务变得更加容易。代码中的其他内容：
- 您的大多数功能似乎都试图向呼叫者建议列表头应通过返回值是什么。相反，他们应该通过in/out param执行。
- 插入新节点相对于另一个插入新节点的任何函数应返回新节点。
-
list_prepend()和list_append()功能应视为 core 插入功能相对于列表头。其他API（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("%sn", 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运行了这一点，没有发现泄漏。我是正面的它不会适合您的需求。
代码看起来还可以。
如何定义list_t？list_t是否有任何成员引用动态分配的内存？如果是这样，您还需要预先释放这些记忆。