释放 C: 队列中的内存

Question

void insert_queue (queue *this, queue_item_t item) {
   //Inserts a new item at the end of queue.
   queue_node *temp = malloc(sizeof (struct queue_node));
   temp->item = item;
   if (isempty_queue(this)) this->front = temp; 
   else this->rear->link = temp;
   this->rear = temp;
   //free(temp);
}
queue_item_t remove_queue (queue *this) {
   assert (! isempty_queue (this));
   //This removes the first item from queue.
   queue_item_t temp = this->front->item;
   this->front = this->front->link;
   return temp;
}

当我尝试释放"temp"时，我收到一个 seg 错误错误。我应该在使用节点后释放它，对吧？那么，在这种情况下如何防止内存泄漏呢？有什么想法吗？谢谢。

当我删除free(temp(时，一切正常，但是我遇到了内存泄漏。如果它不属于此功能，我不确定在哪里放自由。我还添加了删除功能。应该自由进入这里吗？

编辑

编辑：谢谢大家，这是我更新的代码。

queue_item_t remove_queue (queue *this) {
   assert (! isempty_queue (this));
   queue_node *temp = this->front;
   queue_item_t rVal = temp->item;
   //Moves on to the next one.
   this->front = this->front->link;
   //Free the unlinked node.
   //free(temp->item); <<<<---- This causes program to fail.
   free(temp);
   return rVal;
}

内存泄漏仍在发生。

Answer 1

insert_queue完成时，您还没有完成节点的使用。insert_queue例程使用 temp 来保存指向节点的指针，insert_queue在返回时使用 temp 完成，但节点本身是链表的一部分，因此正在使用中。

当remove_queue节点从列表中删除时，您就完成了该节点的使用。 remove_queue应将指向节点的指针传递给free以释放其内存。

不要将temp视为节点。它只是一个临时保存指向节点的指针的对象。节点本身是一个独立的东西。

Answer 2

好吧，如果您要创建和插入一个新队列，为什么要删除它？请记住，当您使用 malloc(( 时，您保留了一些独立于您所在块的数据。Free(( 是你用来销毁使用 malloc(( 创建的内存的内存。所有本地范围(不是使用 malloc 创建的(数据/变量将在它们被尊重的块结束时自动销毁。使用 malloc(( 创建的数据(在大多数情况下(不会。

void insert_queue (queue *this, queue_item_t item)
{
    //Inserts a new item at the end of queue.
    queue_node *temp = malloc(sizeof (struct queue_node));
    temp->item = item;
    if (isempty_queue(this))
        this->front = temp; 
    else
        this->rear->link = temp;
    this->rear = temp;
    //free(temp);    // remember tmp is still referring to
                               // the node, so you will be erasing the
                               // node you just put inside the queue.
}     // end of code block. Variable *temp will be
      // automatically freed from memory, but
      // its malloc'd data will not. This is good
      // because its data is being used inside our
      // queue, until it is removed with remove_queue().

稍后在 remove 函数中，您可以使用 free 删除"temp"(实际上是使用 malloc(( 分配的内存(。或者你可以使用 free(remove_queue(&myq((，它将产生完全相同的结果，因为我们正在处理指针。

Answer 3

首先，"this"是掩盖c ++中的关键字。如果你问我，你也不应该在c上下文中使用它 - 只是为了避免误解。

其次，队列是指项目、请求、人员或某物在最后排队，并在时间(dequed(更早或更晚地从前面删除的东西。您似乎将其实现为链表，这很好。

接下来queue_item_t项目作为原始值的副本分配给这里的堆栈，因为我没有看到它是分配给它的指针，将在关闭 } 时删除。

如果变量 temp 实际上具有像 newQueueNode 这样的含义，我不会调用它。有意义的应用程序/类/变量/函数名称是注释代码的最佳方式之一。

最后评论，选择返回和传递值而不带 ok 参数，否则当您无法返回副本时会遇到问题(请参阅我的 size==0 示例(，并且无法告诉函数的用户出了问题(在这种情况下，队列为空(

这是我(快速生产和测试的(针对您的问题的最低解决方案：

#include <stdlib.h>
#include <stdio.h>
struct queue_item_t
{
    int exampleItemData;
};
struct queue_node
{
    struct queue_item_t *item;
    struct queue_node *next;
};
struct queue
{
    struct queue_node *firstItem;
    struct queue_node *lastItem;
    int size;
};

struct queue* createQueue()
{
    struct queue *queuePtr = (struct queue *)malloc(sizeof (struct queue));
    queuePtr->firstItem = NULL;
    queuePtr->lastItem = NULL;
    queuePtr->size = 0;
    return queuePtr;
}
void queue(struct queue* queueData, struct queue_item_t itemToQueue)
{
    // Create new node
    struct queue_node* newNode = (struct queue_node*)malloc(sizeof(struct queue_node));
    // Create new item
    newNode->item = (struct queue_item_t*)malloc(sizeof(struct queue_item_t));
    // Copy the item data from itemToQueue that will be deleted on the end of this function
    newNode->item->exampleItemData = itemToQueue.exampleItemData;
    // Insert the item into the queue
    if(0 == queueData->size)
    {
        queueData->firstItem = newNode;
        queueData->lastItem = newNode;
        newNode->next = newNode;
    }
    else
    {
        queueData->lastItem->next = newNode;
        queueData->lastItem = newNode;
    }
    queueData->size += 1;
    // ! itemToQueue will deleted here we must have a copy of the data in the queue }
}
struct queue_item_t dequeue(struct queue* queueData)
{
    struct queue_item_t item;
    if (1 > queueData->size)
    {
        // !!! Serious problem if this happens:
        // What will you return, an initialized queue_item_t?
        // You can not return a null pointer ...
        // Better you write ok to a boolean comming in ass parameter or something
    }
    else if(1 == queueData->size)
    {
        item.exampleItemData = queueData->firstItem->item->exampleItemData;
        free(queueData->firstItem->item);
        free(queueData->firstItem);
        queueData->firstItem = NULL;
        queueData->lastItem = NULL;
    }
    else if(2 == queueData->size)
    {
        item.exampleItemData = queueData->firstItem->item->exampleItemData;
        struct queue_node* dequeuedNode = queueData->firstItem;
        queueData->firstItem = dequeuedNode->next;
        queueData->lastItem = dequeuedNode->next;
        free(dequeuedNode->item);
        free(dequeuedNode);
    }
    else if (1 < queueData->size)
    {
        item.exampleItemData = queueData->firstItem->item->exampleItemData;
        struct queue_node* dequeuedNode = queueData->firstItem;
        queueData->firstItem = dequeuedNode->next;
        free(dequeuedNode->item);
        free(dequeuedNode);
    }
    queueData->size -= 1;
    return item;
}

int main() {
    struct queue* myQueue = createQueue();
    struct queue_item_t item;
    item.exampleItemData = 665;
    queue(myQueue, item);
    item.exampleItemData = 666;
    queue(myQueue, item);
    item.exampleItemData = 667;
    queue(myQueue, item);
    for(int i = myQueue->size; i > 0; --i)
    {
        struct queue_item_t dequeuedItem = dequeue(myQueue);
        printf("Dequed ITem data = %in",  dequeuedItem.exampleItemData);
    }
    // Now the next shows an undefined state if someone dequeues with size 0 or smaller:
    struct queue_item_t dequeuedItem = dequeue(myQueue);
    printf("Dequed ITem data = %in",  dequeuedItem.exampleItemData);
    // I recommend using a boolean like mentioned above
    return 0;
}