C++ 中的递归析构函数

Question

假设我有一个类似于以下的类：

#include <vector>

class element
{
public:
   element();
   ~element();

   virtual void my_func();

private:
   std::vector<element*> _elements;
};

我将如何实现析构函数？

我在想这样的事情，但我不确定。我担心内存泄漏，因为我对 C++ 比较陌生。

void element::destroy()
{
   for(int i = 0; i < _elements.size(); ++i)
      _elements.at(i)->destroy();

   if(this != NULL) 
      delete this;
}

element::~element()
{
    destroy();
}

谢谢。

PS： 这是一个示例主要：

int main()
{
   element* el_1 = new element();
   element* el_2 = new element();
   element* el_3 = new element();

   el_1.add_element(el_2);
   el_2.add_element(el_3);

   return 0;
}

另外，如果我这样做（也就是不要使用new）怎么办：

int main()
{
   element el_1;
   element el_2;
   element el_3;

   el_1.add_element(&el_2);
   el_2.add_element(&el_3);

   return 0;
}

Answer 1

element::~element()
{
    typedef std::vector<element*>::const_iterator iterator;
    for (iterator it(_elements.begin()); it != _elements.end(); ++it)
        delete *it;
}

delete this 在析构函数中总是错误的：this 已经被销毁了！

此外，您还需要声明一个复制构造函数和复制赋值运算符（或者让它们未定义，使您的类不可复制，或者提供一个合适的定义来复制树）。

或者（并且最好），您应该为_elements 使用智能指针容器。例如，

std::vector<std::unique_ptr<element>> _elements;

当element 被销毁时，它的_elements 容器将被自动销毁。当容器被销毁时，它会销毁它的每一个元素。一个std::unique_ptr拥有它所指向的对象，当std::unique_ptr被销毁时，它会销毁它所指向的元素。

通过在此处使用std::vector<std::unique_ptr<element>>，您无需提供自己的析构函数，因为所有这些内置功能都会为您完成清理工作。

如果您希望能够复制 element 树，您仍然需要提供自己的复制构造函数和复制赋值运算符来克隆树。但是，如果您不需要树是可复制的，则不需要像自己管理内存那样声明复制操作：std::unique_ptr 容器本身不可复制，因此它作为成员存在变量将抑制隐式生成的复制操作。

Answer 2

class element
{
public:
   element();
   ~element();

private:
   std::vector<element*> _elements;
};

根据Rule of Three，这缺少复制构造函数和赋值运算符的定义。

---

element::~element()
{
    destroy();
}

从析构函数调用delete this（这是destroy() 所做的）总是错误，因为析构函数是在当前对象被调用时调用的删除。

---

for(int i = 0; i < _elements.size(); ++i)
   _elements.at(i)->destroy();

虽然这可以对您调用destroy() 的对象调用delete，但这种安排的缺点是您不得通过调用destroy() 以外的方式销毁此类对象。特别是这个

element el_1;

会是个问题，因为e1_1 会在它掉出作用域bay 调用它的析构函数时被自动销毁。由于这会调用destroy()，它会在未使用new 分配的对象上调用delete this，这会导致未定义行为。 （如果你幸运的话，它会立刻炸到你的脸上。）

最好从析构函数中删除delete this，并且只让析构函数删除对象向量中的对象：

for(std::vector<element*>::size_type i = 0; i < _elements.size(); ++i)
  delete _elements[i];

---

if(this != NULL) 
   delete this;

检查NULLness 的指针从来没有必要，因为delete 被定义为当传递给它的指针是NULL 时什么都不做。

Answer 3

1. delete this 不应该存在，因为根据定义，该对象已经处于破坏状态。

2. 如果复制element，则其成员vector 中的所有指针也会被复制；然后当原始文件超出范围时，它们的指针被销毁，element 副本有一个vector 的悬空指针。您需要一个复制 ctor 和赋值运算符。

所以，仅仅这个基本的开始就已经造成了两个非常严重的错误。这是要避免设计的标志。对于使用它的程序员来说，所有权语义是什么似乎并不那么清楚。

为什么这里需要动态分配？为什么不自己存储elements 对象？

#include <vector>

class element
{
public:
   void add_element(element const& e) {
      _elements.push_back(e);
   }
private:
   std::vector<element> _elements;
};

如果您之前有多个对同一个 element 的引用进入不同的其他 elements，这将巧妙地改变您的程序，但您必须自己决定是否需要这种纠结的依赖关系。

Answer 4

不，这样不行。你永远不会删除this。你只是不这样做。基本上，取出你的销毁方法，将所有内容放入~element()，除了delete this 部分。而不是调用destroy方法，只需delete _elements[i];。