【问题标题】:Is it OK to use "delete this" to delete the current object?可以用“delete this”删除当前对象吗?
【发布时间】:2010-11-18 11:41:28
【问题描述】:

我正在编写一个链表,我希望结构的析构函数(一个 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
{
   delete this;
}

这是否可以接受,尤其是在这种情况下?

【问题讨论】:

标签: c++ linked-list this destructor self-destruction


【解决方案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;
  }
}

【讨论】:

  • 注意:由于您要从 DoublyLinkedList 析构函数中删除所有节点,因此不应在其他任何地方删除 Node 对象。
  • 那么我需要一个节点析构函数吗?我只是不希望编译器提供的 dtor 扰乱我的生活。
  • 你可以放一个留空,也可以不放一个。
  • @hooked,编译器提供的 dtor 相当于只写一个空主体的 dtor。无论你做什么,它都会破坏成员变量和超类——此时你无法停止它(先终止程序)
  • 堆分配的内存也意味着新分配的或malloc分配的。堆栈分配意味着您没有通过 new 或 malloc 动态分配内存。
【解决方案2】:

不,你不应该使用析构函数delete this。由于 delete 语句(或超出范围)而调用了析构函数,这很可能导致某种崩溃。

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

【讨论】:

    【解决方案3】:

    目前,您的代码会导致访问冲突,因为以下第二行显然访问了已释放的内存:

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

    如果你想递归地删除结构,你需要这样的东西:

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

    【讨论】:

    • 这种方法的一个问题是,如果你想删除一个任意节点,你会清除它后面的每个节点。
    • 好点,谢谢。我想避免递归实现,因为我相信这对于大型列表可能会变得低效。
    • OP 的代码不一定会导致 AV - 释放的内存可能会被进程访问,或者可能会返回给操作系统并变得不可访问 - 这取决于堆管理器。
    • @harto:在销毁 this 之前取消链接 next() 很容易避免这种情况。 (如果你有一个双向链表,这似乎更干净,因为否则next()->prev() 将指向一个已删除的节点。)
    • @Hooked:我会先测量,然后再说。对于链表,非局部性(如果这是一个词)可能是主要的性能影响。最重要的是,递归与迭代可能根本没有任何区别。恕我直言,递归方法很自然,似乎很容易理解,所以在我放弃之前,我会测量。
    【解决方案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();
    }
    

    对我来说,这似乎是 dtors 的发明目的,所以,除了现在没有人应该再编写自己的链表类型之外,对我来说,这似乎是 C++ 解决方案问题。

    【讨论】:

    • 不是作业,而是学习练习。我从来没有真正使用过列表。我是 STL 的粉丝,所以不用担心。
    • @Hooked:这下松了一口气。 :^>
    【解决方案5】:

    删除这个;将调用当前对象的析构函数。在这种情况下,如果你打电话删除这个;在析构函数中,则析构函数将被无限调用直到崩溃。

    【讨论】:

      【解决方案6】:

      上面的代码会调用 Node::~Node() 两次。 (在“删除临时”和 Node::~Node() 中)

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

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

      【讨论】:

      • 实际上,Node::~Node() 不会被调用两次,而是由于无限递归而导致堆栈溢出(哈!)。
      【解决方案7】:

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

      值得牢记的一点是,在构造时,您首先创建对象(当控制流进入构造函数的主体时),然后是内部的对象;对于破坏,你必须反过来做,因为如果你先删除外部对象,你将无法访问内部指针来删除它们。相反,您使用析构函数删除内部对象,然后当控制流退出析构函数时,操作系统会管理实际的内存释放。

      顺便说一句,子类化也会发生同样的事情——如果你有类 A 和类 B : public A,那么当你执行 new B() 时,首先执行 A 构造函数,然后执行 B 的构造函数;在销毁时,B 的析构函数首先执行,然后是 A 的。不过,我相当确定您不必担心这一点——C++ 会为您处理好它。所以不要试图找出在超类上调用 delete 的方法。

      【讨论】:

        【解决方案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 this 是合理的以释放当前对象,但不是从析构函数。

        【讨论】:

          猜你喜欢
          • 1970-01-01
          • 1970-01-01
          • 1970-01-01
          • 2013-07-16
          • 2013-10-23
          • 1970-01-01
          • 1970-01-01
          • 2020-01-31
          • 1970-01-01
          相关资源
          最近更新 更多