使用“删除此”可以吗？ 删除当前对象？

Question

我正在编写一个链表，我希望结构的析构函数（Node 结构）能够简单地删除自身，并且不会产生任何副作用。 我希望我的列表的析构函数迭代地调用自身的 Node 析构函数（临时存储下一个节点），如下所示：

//my list class has first and last pointers
//and my nodes each have a pointer to the previous and next
//node
DoublyLinkedList::~DoublyLinkedList
{
    Node *temp = first();

    while (temp->next() != NULL)
    {
        delete temp;
        temp = temp->next();
    }
}

所以这将是我的 Node 析构函数：

Node::~Node
{
   delete this;
}

这可以接受吗，尤其是在这种情况下？

Answer 1

如果 Node 析构函数被调用，那么它已经在被删除的过程中。 因此，删除在 Node 析构函数中没有意义。

这也是错误的：

while (temp->next() != NULL)
{
     delete temp;
     temp = temp->next();
}

相反，您应该将 temp->next() 放入临时变量中。 否则您将访问已删除的内存。

所以更多的是这样的：

DoublyLinkedList::~DoublyLinkedList
{
  Node *temp = first();
  while (temp != NULL)
  {
       Node *temp2 = temp->next();
       delete temp;
       temp = temp2;
  }
}

Answer 2

不，你不应该从析构函数中删除它。 由于删除语句（或超出范围）而调用析构函数，这很可能会导致某种崩溃。

DoublyLinkedList 析构函数中还存在一些问题。 一，删除 temp，然后在删除 temp 后访问 temp。 其次，代码实际上不会删除链表中的最后一个元素。

Answer 3

目前，您的代码会导致访问冲突，因为以下行中的第二行清楚地访问了已释放的内存：

delete temp;
temp = temp->next();

如果您想递归删除该结构，您需要如下所示的内容：

DoublyLinkedList::~DoublyLinkedList
{
    Node *temp = first();
    delete temp;
}

Node::~Node
{
   if(this->next() != NULL) delete this->next();
}

Answer 4

首先：我真的非常希望这是布置给您的家庭作业，以便您理解双向链表。 否则没有理由使用它来代替 std::list。 解决这个问题：

不，在 dtor 中 delete this 总是错误的，因为当 this 处于被删除状态时会调用 dtor。

另外，虽然

delete temp;
temp = temp->next();

偶然可能有效，但它肯定是错误的，因为当您尝试访问 temp->next() 时，temp 已被删除，因此您应该调用成员函数就可以了。 这样做会引发所谓的“未定义行为”。 （简而言之：它可能会做你想做的事，但它也可能总是或偶尔失败，或者仅在 13 号星期五与新月相撞时失败。它还可能会在你身上引发非常令人讨厌的鼻恶魔.)

请注意，您可以通过删除节点 dtor 中的下一个节点来解决这两个问题：

Node::~Node()
{
   delete next();
}

这样，您的列表 dtor 也变得非常容易：

DoublyLinkedList::~DoublyLinkedList()
{
    delete first();
}

对我来说，这似乎是 dtor 的发明目的，所以，除了没有人这样做的事实现在应该不再编写自己的链表类型了，对我来说，这似乎是您问题的C++ 解决方案。

Answer 5

删除这个； 会调用当前对象的析构函数。 在这种情况下，如果您打电话删除此； 在析构函数中，那么析构函数将被无限调用，直到崩溃。

Answer 6

一般来说，析构函数应该只关心删除（或者释放，如果您使用的是 C 或 malloc）专门为您的对象分配的任何内存。 删除指向对象的指针始终由操作系统管理，您不必担心该部分的任何事情。

值得记住的一件事是，在构造时，首先创建对象（当控制流进入构造函数的主体时），然后创建内部的对象； 对于销毁，您必须反向执行此操作，因为如果您先删除外部对象，您将无法访问内部指针来删除它们。 相反，您使用析构函数删除内部对象，然后当控制流脱离析构函数时操作系统管理实际的内存释放。

顺便说一句，子类化也会发生同样的事情——如果你有类 A 和类 B : public A，那么当你执行 new B() 时，首先执行 A 构造函数，然后执行 B 的构造函数； 销毁时，B 的析构函数首先执行，然后是 A 的析构函数。 不过，我相当确定您不必担心这一点——C++ 会为您解决这个问题。 因此，不要试图找出在超类上调用删除的方法。

Answer 7

上面的代码将调用 Node::~Node() 两次。 （在“delete temp”和 Node::~Node() 中）

::~Node() 不应该调用“delete this”（否则你的程序会崩溃）

Node 你的代码中的 while 循环将不起作用。 它将取消引用无效指针。
您应该首先复制 temp->next 的值，然后销毁 temp 指针。

Answer 8

两者都不应该做。

这

DoublyLinkedList::~DoublyLinkedList
{
    Node *temp = first();
    while (temp->next() != NULL)
    {
        delete temp;
        temp = temp->next();
    }
}

将导致未定义的行为 - 您不允许访问已返回到堆的内存。 相反，它应该是：

DoublyLinkedList::~DoublyLinkedList
{
    Node *temp = first();
    while( temp != NULL)
    {
        Node* next = temp->next();
        delete temp;
        temp = next;
    }
}

调用delete this将导致所谓的双重释放，这也会导致未定义的行为。 析构函数应该只对指针成员变量调用delete，而不能对this调用delete。 从其他方法调用 delete this 来释放当前对象是合理的，但在析构函数中则不然。