You should exclude the current node from the delete operator, as the code is already a response to such a delete. Doing it again is like running in circles.
So modify your code to this:
~Node()
{
Node *current = this->next; // exclude current node
Node *previous;
while (current != NULL)
{
previous = current;
current = current->next;
previous->next = NULL; // avoid the delete below to propagate through list.
delete previous;
}
}
There is no need to set previous to NULL, since it will run out of scope. But it is needed to detach previous from its successors, so to avoid the the destructor will follow that chain again.
This code assumes that this is the first node of the list, which would be the natural thing to execute delete on. If for some reason you would execute delete on a node somewhere in the middle of a list, with the aim to discard the whole list, then you would need to repeat the above loop also for the nodes that precede the current node.
#include <iostream>
class Node
{
private:
int data;
Node *next;
public:
explicit Node( int data, Node *next = nullptr ) : data( data ), next( next )
{
}
~Node()
{
std::cout << "Deleting " << data << "...\n";
delete next;
}
};
void push_front( Node *&head, int data )
{
head = new Node( data, head );
}
int main()
{
Node *head = nullptr;
const int N = 10;
for (int i = 0; i < N; i++)
{
push_front( head, N - i );
}
delete head;
}
You may not delete the current node itself because otherwise the code invokes undefined behavior.
Instead you could write
~Node()
{
delete next;
}
And if the list is defined as a pointer to the head node then you need to write
delete head;
Here is a demonstration program
#include <iostream>
class Node
{
private:
int data;
Node *next;
public:
explicit Node( int data, Node *next = nullptr ) : data( data ), next( next )
{
}
~Node()
{
std::cout << "Deleting " << data << "...\n";
delete next;
}
};
void push_front( Node *&head, int data )
{
head = new Node( data, head );
}
int main()
{
Node *head = nullptr;
const int N = 10;
for (int i = 0; i < N; i++)
{
push_front( head, N - i );
}
delete head;
}
发布评论
评论（2）
您应该从
delete运算符中排除当前节点，因为代码已经是对delete的响应。再次这样做就像盘旋。因此，将您的代码修改为：
无需将
上一个设置为null，因为它将用尽范围。但是，需要从其后继者中脱离上一个，因此为避免，灾难将再次遵循该链条。该代码假设
此是列表的第一个节点，这是执行deleteon的自然而然的事情。如果由于某种原因您将在列表中间的某个地方的节点上执行delete，目的是丢弃整个列表，那么您还需要重复上述循环的节点。当前节点。You should exclude the current node from the
deleteoperator, as the code is already a response to such adelete. Doing it again is like running in circles.So modify your code to this:
There is no need to set
previoustoNULL, since it will run out of scope. But it is needed to detachpreviousfrom its successors, so to avoid the the destructor will follow that chain again.This code assumes that
thisis the first node of the list, which would be the natural thing to executedeleteon. If for some reason you would executedeleteon a node somewhere in the middle of a list, with the aim to discard the whole list, then you would need to repeat the above loop also for the nodes that precede the current node.您不得删除当前节点本身，因为否则代码会调用未定义的行为。
您可以编写
列表定义为指向头节点的指针
，如果
相反，
You may not delete the current node itself because otherwise the code invokes undefined behavior.
Instead you could write
And if the list is defined as a pointer to the head node then you need to write
Here is a demonstration program
The program output is