从析构函数内部调用 delete 会导致堆栈溢出吗？

Question

以下代码创建一个指向B* 的双指针B**。它将使用该指针为另一个指针分配内存，该指针将指向在调用start() 时创建的B 实例：

class A:

class A
{
public:
    A()
    {
        fb = new B*;
        *fb = NULL;
    }

    ~A()
    {
        if(*fb)
            delete *fb;

        delete fb;
    }

    B** getfb()
    {
        return fb;
    }

private:
    B** fb;
};

class B:

class B
{
public:
    B()
    {
        B** fb = a->getfb();

        *fb = this;
    }

    ~B()
    {
        B** fb = a->getfb();

        delete *fb;            // <--- stack overflow

        *fb = NULL;
    }

private:
    A* a;
};

start()（class C的成员函数）：

void C::start()
{
    B** fb = a->getfb();        // 'a' is a pointer to an 'A' instance

    if(*fb == NULL)
        B* f = new B;
}

所以，每当我调用start() 然后再调用~B() 时，都会出现堆栈溢出！

Answer 1

听起来不错。

fb 的类型是B**，所以*fb 的类型是B*。

因此，当您说 delete *fb 时，您正在调用 class B 的析构函数，这是一个递归调用，不会对基本情况取得进展，因此堆栈溢出。

Answer 2

在B() 中分配*fb = this; 然后：

~B()
{
  ...
  delete *fb; // delete this;
  ...
}

.. 相当于在析构函数~B() 中一次又一次地调用delete this;，因此由于递归函数太多而导致stackoveflow。

这是Is it safe to delete this 的一个不错的帖子。

Answer 3

这并不奇怪。您在 B 类的析构函数中，访问当前正在调用其析构函数的 B 的相同实例，然后再次将其删除。这将导致析构函数调用中的递归，从而导致堆栈溢出。您在 A 类删除 fb 足以清理您的记忆，您不希望 B 类自行删除。

您也不需要在 B 类构造函数中执行您正在执行的操作。你在 A 类中的代码是有道理的，你在 B 类中的代码是危险的和不必要的。在 B 类中，您没有设置其成员 a 的功能。这意味着指针未初始化，然后您尝试将此 B 类实例分配给 A 的此 未初始化 实例的 B 类成员指针。

    B()
    {
        B** fb = a->getfb(); // a never gets set to a meaningful value!!!!!

        *fb = this;
    }