销毁大型列表会溢出我的堆栈吗？

考虑以下单链表实现：

struct node {
    std::unique_ptr<node> next;
    ComplicatedDestructorClass data;
}

现在，假设我停止使用某个std::unique_ptr<node> head超出范围的实例，从而导致其析构函数被调用。

这会否使我的堆栈大到无法容纳足够大的列表？假设编译器会做一个相当复杂的优化（将inline unique_ptr的析构函数插入node，然后使用尾部递归）是否公平，如果我执行以下操作，这会变得更加困难（因为data析构函数会混淆next's'，使其变得困难）让编译器注意到潜在的重新排序和尾部调用机会）：

struct node {
    std::shared_ptr<node> next;
    ComplicatedDestructorClass data;
}

如果data某种程度上有指向它的指针，node那么尾部递归甚至是不可能的（尽管我们当然应该努力避免这种封装破坏）。

通常，那么应该如何销毁该列表呢？我们无法遍历列表并删除“当前”节点，因为共享指针没有release！唯一的方法是使用自定义删除器，这对我来说真的很臭。

是的，除非最终编译器恰好对node'的析构函数和 shared_ptr '的析构函数进行尾部调用优化，否则这最终将使您的堆栈崩溃。后者非常依赖于标准库的实现。例如，Microsoft的STL将永远不会这样做，因为shared_ptr首先减小其指针的引用计数（可能会破坏对象），然后减小其控制块的引用计数（弱引用计数）。因此，内部析构函数不是尾部调用。这也是一个虚拟调用，这使得优化的可能性更低。

典型的列表通过不让一个节点拥有下一个节点来解决该问题，而是通过使一个容器拥有所有节点，并使用循环来删除析构函数中的所有内容来解决该问题。

答案很晚，但由于没有人提供……我遇到了同样的问题，并使用自定义析构函数解决了这个问题：

virtual ~node () throw () {
    while (next) {
        next = std::move(next->next);
    }
}

如果您确实有一个list，即每个节点之前都有一个节点并且最多有一个跟随者，而您list是第一个跟随者的指针node，则上面的内容应该起作用。

如果您具有某种模糊结构（例如，非循环图），则可以使用以下内容：

virtual ~node () throw () {
    while (next && next.use_count() < 2) {
        next = std::move(next->next);
    }
}

这样做的想法是：

next = std::move(next->next);

旧的共享指针next被销毁了（因为它use_count现在是0），您可以指向以下内容。这与默认析构函数完全相同，不同之处在于它以迭代方式而不是递归地进行，从而避免了堆栈溢出。

老实说，我对任何C ++编译器的智能指针释放算法都不熟悉，但是我可以想象有一个简单的，非递归算法可以做到这一点。考虑一下：

• 您有一个等待释放的智能指针队列。
• 您具有一个函数，该函数采用第一个指针并对其进行分配，然后重复该操作直到队列为空。
• 如果智能指针需要释放，则将其推入队列并调用上述函数。

因此，堆栈没有机会溢出，优化递归算法要简单得多。

我不确定这是否适合“几乎零成本的智能指针”理念。

我想您所描述的不会导致堆栈溢出，但是您可以尝试构建一个聪明的实验来证明我错了。

更新

好吧，这证明了我之前写的错误：

#include <iostream>
#include <memory>

using namespace std;

class Node;

Node *last;
long i;

class Node
{
public:
   unique_ptr<Node> next;
   ~Node()
   {
     last->next.reset(new Node);
     last = last->next.get();
     cout << i++ << endl;
   }
};

void ignite()
{
    Node n;
    n.next.reset(new Node);
    last = n.next.get();
}

int main()
{
    i = 0;
    ignite();
    return 0;
}

该程序永久地构建和解构节点链。确实会导致堆栈溢出。