对于在同一地址构造两次的对象，编译器如何知道必须调用第二个析构函数？

Question

在下面的代码中，类 C 中的对象 sub 被构造了两次。第一个构造调用默认构造函数 Sub()，第二个构造使用 placement new 在同一地址重建此对象。

因此析构函数也被调用两次。第一个调用使用对 ~C() 中的 Sub dtor 的直接调用，第二个调用在 main() 结束后调用，我相信，通过 atexit() 函数。

假设对象 sub 在同一地址重建，编译器如何知道必须在 main() 之后调用第二个析构函数？他将这些信息保存在哪里？

#include <iostream>
using namespace std;

struct Table
{
    int i;
    Table(int j) : i(j) {}
};

struct Sub
{
    Table* pTable;
    Sub(int j) { cout << "ctor placement new" << endl; pTable = new Table(j); }
    Sub() { cout << "ctor default" << endl; pTable = 0; }
    ~Sub() { if( pTable ) cout << "dtor placement new" << endl;
             else         cout << "dtor default" << endl;
             delete pTable; pTable = 0; }
};

class C
{
    Sub sub;

    public:
    C() { new (&sub) Sub(10); }
    ~C() { (&sub)->~Sub(); }
};

int main()
{
    C c;
}

Answer 1

您对 atexit() 的假设是不正确的。当对象 c 超出 main()C 的析构函数将调用 sub 的析构函数>。

C++ 析构函数总是为其所有子对象调用析构函数。

无论如何，您的代码都是无效的，因为您正在对已经构造成对象的内存块 (sub) 调用放置 new 运算符。与析构函数类似，C++ 构造函数总是为其所有子对象调用构造函数。

Answer 2

虽然这显然是未定义的行为，但如果你推理出发生了什么，那就很明显了。

您创建了类 C 的对象。在此过程中，隐式调用 Sub 的默认构造函数。 pTable 为 0。然后，显式调用 int 构造函数来初始化 pTable。然后，在析构函数中，显式调用 Sub 的析构函数。 pTable 再次设置为 0。然后，在 C 的析构函数结束时，再次隐式调用 Sub 的析构函数。

它并不是在 main 的末尾发生的。它发生在 C 析构函数的末尾。

Answer 3

当 c 超出范围时，将调用其析构函数。 C 析构函数将显式调用子析构函数。当 C 析构函数完成时，子析构函数也将被（再次）调用，因为所有 C++ 析构函数都会自动调用其所有内部对象的析构函数。

本质上，该代码

(&sub)->~Sub();

是不必要的，而且是不正确的。您永远不应该显式调用托管对象的析构函数。

编辑：
在通过放置 new 构造的对象上显式调用析构函数是有效的。然而，只有当对象不受管理时才会出现这种情况。例如：

class C
{
    Sub sub[1];

    public:
    C() { new (sub) Sub(10); }
    ~C() { sub->~Sub(); }
};

这不仅是有效的，而且是必要的，因为 C 的成员是 Sub[1] 类型（或更一般的 Sub*），因此当 C 被销毁时，不会显式调用 Sub 的析构函数。

Answer 4

其他答案对未定义的行为提出了有效的观点，但令我惊讶的是没有人提到应该如何纠正这个程序。

Sub 的析构函数确实需要在这里手动调用，但是需要在放置 new 之前调用，而不是在销毁期间调用

class C
{
    Sub sub;

    public:
    C() { 
        (&sub)->~Sub();
        new (&sub) Sub(10); 
    }
};

：当前代码您创建一个 C 实例，默认构造一个 Sub 实例，然后立即放置消息另一个 Sub 实例code> 位于旧代码之上，而不调用其析构函数。在 main c 的析构函数被调用的最后，显式调用 sub 的析构函数，然后 sub 的析构函数被再次调用已经被破坏的物体。这不仅是未定义的行为，如果分配了 Sub 的默认构造函数，您也会遇到内存泄漏。

在更正后的代码中，sub 是默认构造的，手动析构，通过放置 new 构造，然后当 c 在 main 末尾超出范围时隐式析构。

所以答案是编译器不知道当您在同一地址重新创建对象时需要调用析构函数，因为放置 new 不接受对象它采用 void* 作为其第一个参数。它无法确定该指针是否指向现有对象，因此您必须手动调用析构函数。