有没有一种方法可以调用纯虚类的“删除析构函数”？

Question

我正在使用Ubuntu Trusty上的C++11和g++4.8。

考虑以下代码片段：

class Parent {
public:
    virtual ~Parent() =  default;
    virtual void f() = 0;
};

class Child: public Parent {
public:
    void f(){}
};

使用时调用

{
    Child o;
    o.f();
}
{
    Parent * o  = new Child;
    delete o;
}
{
    Child * o  = new Child;
    delete o;
}

我使用gcov生成代码覆盖率报告。它报告说符号_ZN6ParentD0Ev的析构函数从未被调用，而_ZN6ParentD2Ev则被调用。

回答Dual emission of constructor symbols和GNU GCC (g++): Why does it generate multiple dtors?指出_ZN6ParentD0Ev是删除构造函数。

是否有任何情况下Parent类会调用这个"删除析构函数"？

附加问题：如果不是这样，请问有没有办法让gcov/lcov代码覆盖率工具（使用Detailed guide on using gcov with CMake/CDash?的答案）在其报告中忽略该符号？

- rcomblen

---

那么答案是“不行，没有办法获取该函数的覆盖率”吗？ - Gillespie

你最终解决了如何让 gcov 忽略那个符号的问题吗？ - Gillespie

如果我没记错的话，我只是使用标准的GCOV结构化注释忽略了析构函数的覆盖率。 - rcomblen

你是在问 LCOV 排除标记吗？http://ltp.sourceforge.net/coverage/lcov/geninfo.1.php - Gillespie

好的，是的，我能够使用 LCOV_EXCL_START 和 LCOV_EXCL_STOP 包围派生类来抑制它。 - Gillespie

Answer 1

我认为是因为你有Child对象，而不是Parent对象。

{
    Child o;
    o.f();
} // 1

{
    Parent * o  = new Child;
    delete o;
} // 2

{
    Child * o  = new Child;
    delete o;
} // 3

在// 1中，o被销毁，调用了Child的完整对象析构函数。由于Child继承了Parent，因此它将调用Parent的基类对象析构函数，即_ZN6ParentD2Ev。

在// 2中，o是动态分配并删除的，调用了Child的删除析构函数。然后，它将调用Parent的基类对象析构函数。在两种情况下都调用了基类对象析构函数。 // 3与// 2相同，只是o的类型不同。

---

我在cygwin和g++ 4.8.3以及Windows 7 x86 SP1上进行了测试。以下是我的测试代码。

class Parent
{
public:
    virtual ~Parent() { }
    virtual void f() = 0;
};

class Child : public Parent
{
public:
    void f() { }
};

int main()
{
    {
        Child o;
        o.f();
    }
    {
        Parent * o  = new Child;
        delete o;
    }
    {
        Child * o  = new Child;
        delete o;
    }
}

编译和Gcov选项：

$ g++ -std=c++11 -fprofile-arcs -ftest-coverage -O0 test.cpp -o test
$ ./test
$ gcov -b -f test.cpp

这是结果。

        -:    0:Source:test.cpp
        -:    0:Graph:test.gcno
        -:    0:Data:test.gcda
        -:    0:Runs:1
        -:    0:Programs:1
function _ZN6ParentC2Ev called 2 returned 100% blocks executed 100%
        2:    1:class Parent
        -:    2:{
        -:    3:public:
function _ZN6ParentD0Ev called 0 returned 0% blocks executed 0%
function _ZN6ParentD1Ev called 0 returned 0% blocks executed 0%
function _ZN6ParentD2Ev called 3 returned 100% blocks executed 75%
        3:    4:    virtual ~Parent() = default;
call    0 never executed
call    1 never executed
branch  2 never executed
branch  3 never executed
call    4 never executed
branch  5 taken 0% (fallthrough)
branch  6 taken 100%
call    7 never executed
        -:    5:    virtual void f() = 0;
        -:    6:};
        -:    7:
function _ZN5ChildD0Ev called 2 returned 100% blocks executed 100%
function _ZN5ChildD1Ev called 3 returned 100% blocks executed 75%
function _ZN5ChildC1Ev called 2 returned 100% blocks executed 100%
        7:    8:class Child : public Parent
call    0 returned 100%
call    1 returned 100%
call    2 returned 100%
branch  3 taken 0% (fallthrough)
branch  4 taken 100%
call    5 never executed
call    6 returned 100%
        -:    9:{
        -:   10:public:
function _ZN5Child1fEv called 1 returned 100% blocks executed 100%
        1:   11:    void f() { }
        -:   12:};
        -:   13:
function main called 1 returned 100% blocks executed 100%
        1:   14:int main()
        -:   15:{
        -:   16:    {
        1:   17:        Child o;
        1:   18:        o.f();
call    0 returned 100%
call    1 returned 100%
        -:   19:    }
        -:   20:    {
        1:   21:        Parent * o  = new Child;
call    0 returned 100%
call    1 returned 100%
        1:   22:        delete o;
branch  0 taken 100% (fallthrough)
branch  1 taken 0%
call    2 returned 100%
        -:   23:    }
        -:   24:    {
        1:   25:        Child * o  = new Child;
call    0 returned 100%
call    1 returned 100%
        1:   26:        delete o;
branch  0 taken 100% (fallthrough)
branch  1 taken 0%
call    2 returned 100%
        -:   27:    }
        1:   28:}

正如您所看到的，_ZN6ParentD2Ev，即Base的基本对象析构函数被调用，而其他Base的析构函数没有被调用。

然而，_ZN5ChildD0Ev，即Child的删除析构函数被调用了两次，而_ZN5ChildD1Ev，即Child的完整对象析构函数被调用了三次，因为有delete o;和Child o;。

但根据我的解释，_ZN5ChildD0Ev应该被调用两次，_ZN5ChildD1Ev应该被调用一次，是吗？为了找出原因，我做了这个：

$ objdump -d test > test.dmp

结果：

00403c88 <__ZN5ChildD0Ev>:
  403c88:   55                      push   %ebp
  403c89:   89 e5                   mov    %esp,%ebp
  403c8b:   83 ec 18                sub    $0x18,%esp
  403c8e:   a1 20 80 40 00          mov    0x408020,%eax
  403c93:   8b 15 24 80 40 00       mov    0x408024,%edx
  403c99:   83 c0 01                add    $0x1,%eax
  403c9c:   83 d2 00                adc    $0x0,%edx
  403c9f:   a3 20 80 40 00          mov    %eax,0x408020
  403ca4:   89 15 24 80 40 00       mov    %edx,0x408024
  403caa:   8b 45 08                mov    0x8(%ebp),%eax
  403cad:   89 04 24                mov    %eax,(%esp)
  403cb0:   e8 47 00 00 00          call   403cfc <__ZN5ChildD1Ev>
  403cb5:   a1 28 80 40 00          mov    0x408028,%eax
  403cba:   8b 15 2c 80 40 00       mov    0x40802c,%edx
  403cc0:   83 c0 01                add    $0x1,%eax
  403cc3:   83 d2 00                adc    $0x0,%edx
  403cc6:   a3 28 80 40 00          mov    %eax,0x408028
  403ccb:   89 15 2c 80 40 00       mov    %edx,0x40802c
  403cd1:   8b 45 08                mov    0x8(%ebp),%eax
  403cd4:   89 04 24                mov    %eax,(%esp)
  403cd7:   e8 a4 f9 ff ff          call   403680 <___wrap__ZdlPv>
  403cdc:   a1 30 80 40 00          mov    0x408030,%eax
  403ce1:   8b 15 34 80 40 00       mov    0x408034,%edx
  403ce7:   83 c0 01                add    $0x1,%eax
  403cea:   83 d2 00                adc    $0x0,%edx
  403ced:   a3 30 80 40 00          mov    %eax,0x408030
  403cf2:   89 15 34 80 40 00       mov    %edx,0x408034
  403cf8:   c9                      leave  
  403cf9:   c3                      ret    
  403cfa:   90                      nop
  403cfb:   90                      nop

是的，因为_ZN5ChildD0Ev调用了_ZN5ChildD1Ev，所以_ZN5ChildD1Ev被调用了三次。(1 + 2) 我猜这只是GCC的一种实现方式，旨在减少重复代码。

- ikh

---

这是否意味着在删除对象时，只会调用最终/实际类型的“deleting destructor”，而不是继承层次结构中的任何其他析构函数？如果是这样，那么显然它永远不会在“Parent”上被调用。 - rcomblen

Answer 2

您不能有父对象，因此不可以。这是GCC的一个疏忽，导致生成了这个无用函数。优化器应该删除它，因为它未被使用，但我发现在这方面GCC也存在问题。

- MSalters

Answer 3

如ikh所解释的那样，当纯虚拟父类有一个虚拟析构函数时，D0析构函数是不必要的（也无法使用）。

然而，如果纯虚拟父类有一个非虚拟析构函数，你可以删除指向父类型的指针，这将调用父类的D0析构函数。当然，在父类中使用非虚拟析构函数很少是可取或预期的，因此g++会发出警告：[-Wdelete-non-virtual-dtor]。

- Cort Tompkins