GNU GCC (g++)：为什么它会生成多个 dtor？

Question

开发环境：GNU GCC (g++) 4.1.2

当我试图研究如何在单元测试中增加“代码覆盖率 - 特别是函数覆盖率”时，我发现一些类 dtor 似乎被多次生成。请问你们中的一些人知道为什么吗？

我通过使用以下代码尝试并观察了上面提到的内容。

在“test.h”中

class BaseClass
{
public:
    ~BaseClass();
    void someMethod();
};

class DerivedClass : public BaseClass
{
public:
    virtual ~DerivedClass();
    virtual void someMethod();
};

在“test.cpp”中

#include <iostream>
#include "test.h"

BaseClass::~BaseClass()
{
    std::cout << "BaseClass dtor invoked" << std::endl;
}

void BaseClass::someMethod()
{
    std::cout << "Base class method" << std::endl;
}

DerivedClass::~DerivedClass()
{
    std::cout << "DerivedClass dtor invoked" << std::endl;
}

void DerivedClass::someMethod()
{
    std::cout << "Derived class method" << std::endl;
}

int main()
{
    BaseClass* b_ptr = new BaseClass;
    b_ptr->someMethod();
    delete b_ptr;
}

当我构建上面的代码（g++ test.cpp -o test）然后查看生成了什么样的符号，如下所示，

nm --demangle test

我可以看到以下内容输出。

==== following is partial output ====
08048816 T DerivedClass::someMethod()
08048922 T DerivedClass::~DerivedClass()
080489aa T DerivedClass::~DerivedClass()
08048a32 T DerivedClass::~DerivedClass()
08048842 T BaseClass::someMethod()
0804886e T BaseClass::~BaseClass()
080488f6 T BaseClass::~BaseClass()

我的问题如下。

1）为什么生成了多个dtor（BaseClass - 2，DerivedClass - 3）？

2）这些dtor有什么区别？如何选择性地使用这些多个 dtor？

我现在有一种感觉，为了实现 C++ 项目 100% 的函数覆盖率，我们需要理解这一点，以便我可以在单元测试中调用所有这些 dtor。

如果有人能给我上述答复，我将不胜感激。

Answer 1

首先，Itanium C++ ABI;请参阅“基本对象析构函数”、“完整对象析构函数”和“删除析构函数”下的定义。 5.1.4 中给出了到损坏名称的映射。

基本上：

• D2 是“基础对象析构函数”。它破坏对象本身以及数据成员和非虚拟基类。
• D1 是“完整的对象析构函数”。它还会破坏虚拟基类。
• D0 是“删除对象析构函数”。它执行完整对象析构函数执行的所有操作，此外还调用operator delete 来实际释放内存。

如果没有虚拟基类，则 D2 和 D1 是相同的；在足够的优化级别上，GCC 实际上会将两者的符号别名为相同的代码。

Answer 2

通常有两种构造函数变体（not-in-charge / in-charge）和三种析构函数（not-in-charge） > / 负责 / 负责删除）。

当使用 virtual 关键字处理从另一个类继承的类的对象时，如果该对象不是完整的对象，则使用 not-in-charge ctor 和 dtor （因此当前对象“不负责”构造或销毁虚拟基础对象）。该构造函数接收指向虚拟基础对象的指针并存储它。

in-charge ctor 和 dtors 适用于所有其他情况，即如果不涉及虚拟继承；如果类有一个虚拟析构函数，负责删除的dtor指针会进入vtable槽，而作用域知道对象的动态类型（即具有自动或静态存储持续时间的对象）将使用负责 dtor（因为不应释放此内存）。

代码示例：

struct foo {
    foo(int);
    virtual ~foo(void);
    int bar;
};

struct baz : virtual foo {
    baz(void);
    virtual ~baz(void);
};

struct quux : baz {
    quux(void);
    virtual ~quux(void);
};

foo::foo(int i) { bar = i; }
foo::~foo(void) { return; }

baz::baz(void) : foo(1) { return; }
baz::~baz(void) { return; }

quux::quux(void) : foo(2), baz() { return; }
quux::~quux(void) { return; }

baz b1;
std::auto_ptr<foo> b2(new baz);
quux q1;
std::auto_ptr<foo> q2(new quux);

结果：

• foo、baz 和 quux 的每个 vtable 中的 dtor 条目都指向相应的负责人删除dtor。
• b1 和 b2 由 baz() in-charge 构造，它调用 foo(1) in-charge
• q1 和 q2 由 quux() in-charge 构造，即 foo(2) in-charge 和 baz() not-in-charge 带有指向之前构造的 foo 对象的指针
• q2 被 ~auto_ptr() in-charge 破坏，它调用虚拟 dtor ~quux() < em>负责删除，调用~baz() 非负责人、~foo() 负责人和操作员删除。
• q1 被 ~quux() in-charge 破坏，它调用 ~baz() 不-in-charge 和 ~foo() in-charge
• b2 被 ~auto_ptr() in-charge，调用虚拟 dtor ~baz() 负责删除，它调用 ~foo() 负责 和 < code>operator delete
• b1 被 ~baz() in-charge 破坏，它调用 ~foo() 负责

任何来自quux 将使用其not-in-charge ctor 和 dtor 并承担创建 foo 对象的责任。

原则上，没有虚拟基的类永远不需要 not-in-charge 变体；在这种情况下，负责变体有时被称为统一，和/或负责和的符号not-in-charge 是单个实现的别名。