避免析构函数中的无限递归

Question

作为我的大学要求我完成的一项练习的一部分，我编写了一个小型 Graph 实现，遵循此标题。

class Node {

private:
    std::string name;
    std::vector<Node*> children;

public:
    Node(const std::string& name="");
    virtual ~Node();

}

在为析构函数~Node() 编写代码时，我注意到当图形包含循环时我的实现会失败。这是我目前的实现，如果图表包含循环，这显然不起作用。

Node::~Node() {
    for (Node* n : children) {
        delete n;
        n = NULL;
    }
    children.clear();
}

我不确定如何最优雅地编写一个可以处理图中循环的析构函数？

请注意，我专门负责编写递归析构函数。 感谢您的回答！

Answer 1

选项 1：为图选择一种表示，其中节点不属于其他节点，而是选择作为不同对象的图。这样节点析构函数就不需要做任何事情了。 _{这不满足递归的要求}：

struct Graph {
    std::vector<std::unique_ptr<Node>> nodes;
};

请注意，如果不涉及继承，那么您可以简单地使用std::vector<Node>。我假设有，由于在Node 中使用了虚拟破坏器。

或者，您可以为图形使用另一种表示形式，例如邻接列表。

选项 2：使用算法生成图的最小生成森林。然后递归删除每个生成树的根。例如，您可以使用 Kruskal 算法。 （根据您的表示，您的图表看起来可能是连接的，在这种情况下将只有一棵生成树）。

Answer 2

一种选择可能是首先创建所有Node*s 中的unordered_set，然后再创建delete。

void fill(std::unordered_set<Node*>& to_delete, Node* ptr) {
    // try to insert ptr and return if it was already in the set
    if(not to_delete.emplace(ptr).second) return;

    // swap ptr->children with an empty vector
    std::vector<Node*> tmp;
    std::swap(tmp, ptr->children);

    for(Node* c : tmp)       // loop over the pointers
        fill(to_delete, c);  // fill recursively
}

virtual ~Node() {
    if(children.empty()) return;          // nothing to do here

    std::unordered_set<Node*> to_delete;  // to collect all the Node*'s
    fill(to_delete, this);                // fill the set recursively
    to_delete.erase(this);                // don't delete "this"

    for(auto c : to_delete)               // delete all - they have no children by now
        delete c;
}

Demo

Answer 3

如果您的图是一棵树（我假设它是因为您的析构函数的实现仅对树有效）并且您可以存储 Node 的父级，那么您可以编写不需要任何额外数据结构的迭代版本避免递归。

还要学习使用智能指针。

class Node {

private:
    std::string name;
    std::vector<std::unique_ptr<Node>> children;
    Node* parent;

    void safeCleanClildren();
public:
    Node(std::string name="", Node* parent = nullptr)
        : name{std::move(name)}
    {}

    ~Node() {
       iterativeCleanClildren();
    }

    void addChild(std::string name) {
        children.emplace_back(std::make_unique<Node>(std::move(node), this);
    }
};

void Node::iterativeCleanClildren()
{
    auto p = this;
    while (!p->children.empty()) {
        while (!p->children.empty()) {
            p = p->back().get(); // go as deep as possible
        }
        if (p != this) {
           p = p->parent; // go back to parent
           p->children.pop_back();
        }
    }
}

这是如何工作的？

1. 首先它在树（没有子节点的节点）中找到叶子（最右边）
2. 然后返回父节点并删除刚刚找到的子节点p->children.pop_back();（这会破坏刚刚找到的叶子的unique_ptr）。
3. 然后再次找到叶子等等。
4. 此树清除继续进行，直到到达根 (this) 节点

这种方式根节点完全没有子节点，因为它是迭代实现溢出是不可能的。这棵树有多不平衡并不重要。