在堆栈中创建对象时，即使代码覆盖率为 100%，函数覆盖率也较小

Question

我正在用 gcov 分析我的代码。它说当在堆栈中创建对象时，我的代码少了 2 个函数。但是当我执行 new-delete 时，实现了 100% 的函数覆盖率。

代码：

class Animal
{
public:
    Animal()
    {
    }
    virtual ~Animal()
    {
    }
};

int main()
{
    Animal animal;
}

我为生成 gcov 报告而执行的命令。

rm -rf Main.g* out.txt a.out coverage;
g++ -fprofile-arcs -ftest-coverage -lgcov -coverage Main.cpp;
./a.out;
lcov --capture --directory . --output-file out.txt;
genhtml out.txt --output-directory coverage;

生成的 html 显示我的功能覆盖率为 3/4 - 75%。

但是一旦我将堆栈对象更改为堆，

代码：

class Animal
{
public:
    Animal()
    {
    }
    virtual ~Animal()
    {
    }
};

int main()
{
    auto animal = new Animal;
    delete animal;
}

我的函数覆盖率是 100%。

只有调用"new"和"delete"时才调用的隐藏函数有哪些？

Answer 1

他们是 allocating constructor and deallocating destructor。

这是 g++ 的实现细节。

Answer 2

简而言之：g++ 为 class

创建了两个析构函数

一个用于破坏对象。
一个用于销毁在堆上分配的对象。

在某些情况下，它们都保存在目标文件中，而在某些情况下仅被使用。在你的 75%-coverage-example 中，你只使用了第一个析构函数，但两者都必须保存在目标文件中。

@MSalters 的回答中的 link 显示了方向，但它主要是关于 g++ 发出的多个 constructor/destructor 符号。

至少对我来说，从这个 linked 的回答中并不能直接看出发生了什么，因此我想详细说明一下。

第一个案例（100%覆盖率）：

让我们从 Animal-class 的稍微不同的定义开始，没有 virtual 析构函数：

class Animal
{
public:
    Animal(){}
    ~Animal(){}
};

int main(){Animal animal;}

对于此 class-定义 lcov 显示 100% 的代码覆盖率。

让我们看一下目标文件中的符号（为了简单起见，我没有使用gcov构建它）：

nm main.o
0000000000000000 T main
             U __stack_chk_fail
0000000000000000 W _ZN6AnimalC1Ev
0000000000000000 W _ZN6AnimalC2Ev
0000000000000000 n _ZN6AnimalC5Ev
0000000000000000 W _ZN6AnimalD1Ev
0000000000000000 W _ZN6AnimalD2Ev
0000000000000000 n _ZN6AnimalD5Ev

编译器只保留 main 中需要的那些内联函数（在 class 定义中实现的函数被视为内联函数，例如没有复制构造函数或赋值运算符，由编译器自动定义）。我不确定 AnimalX5Ev 是什么，但是对于这个 class AnimalXC1Ev（完整对象构造函数）和 AnimalXC2Ev（基本对象构造函数）没有区别 - 它们有即使是同一个地址。正如 linked answer 中所解释的，这是 gcc 的一些怪癖（但 clang 也有）和多态支持的副产品。

第二种情况（75%覆盖率）：

让我们像原始示例中那样将析构函数设为虚拟，并查看生成的目标文件中的符号：

 nm main.o
 0000000000000000 T main
             ...
 0000000000000000 W _ZN6AnimalD0Ev    <----------- NEW
             ...
 0000000000000000 V _ZTV6Animal       <----------- NEW

我们看到了一些新符号：_ZTV6Animal 是众所周知的 vtable，而 _ZN6AnimalD0Ev - 所谓的删除析构函数（继续阅读以了解为什么需要它） .然而，在 main 中再次仅使用 _ZN6AnimalD1Ev，因为与第一种情况相比没有任何变化（使用 g++ -S main.cpp -o main.s 编译以查看）。

但是如果不使用的话，为什么 _ZN6AnimalD0Ev 保存在目标文件中呢？因为在虚table中使用_ZTV6Animal（见汇编main.s）：

_ZTV6Animal:
   .quad    0
   .quad    _ZTI6Animal
   .quad    _ZN6AnimalD1Ev
   .quad    _ZN6AnimalD0Ev  <---- HERE is the address of the function!
   .weak    _ZTI6Animal

但为什么需要这个 vtable？因为 class 的每个对象都有对 class 的 vtable 的引用，只要 class 中有虚方法，就可以在构造函数（仍然 main.s）：

ZN6AnimalC2Ev:
    ...
    // in register %rdi is the address of the newly created object  
    movl    $_ZTV6Animal+16, (%rdi)     ;write the address of the vtable (why +16?) to the address pointed to by %rdi.
...

我必须承认，我稍微简化了汇编，但很容易看出，Animal-对象的内存布局从虚拟 table 的地址开始。

这个释放析构函数 _ZN6AnimalD0Ev 是缺少覆盖的函数 - 因为它没有在您的程序中使用。

第三种情况（再次100%覆盖率）：

如果我们使用 new+delete 会有什么变化？首先我们必须知道，在堆上销毁对象与在堆栈上调用对象的析构函数有点不同，因为我们需要：

销毁对象（它与堆栈相同，即_ZN6AnimalD1Ev）
Release/free堆上对象占用的内存。

这两个步骤在解除分配的析构函数中捆绑在一起 _ZN6AnimalD0Ev，在程序集中再次可以看到：

_ZN6AnimalD0Ev:
    call    _ZN6AnimalD1Ev    ; <---- call "Stack"-destructor
    ....
    call    _ZdlPv            ; free heap memory
    ....

现在，在main中，我们必须从堆中删除对象，因此必须调用D0-destructor-version，它会调用D1-destructor-version轮到它了——这意味着所有的功能都被使用了——覆盖率再次达到 100%。

最后一块拼图，为什么D0-destructor是virtual table的一部分？如果 animal 是 Cat，main 怎么知道要调用哪个解除分配的析构函数（Cat 而不是 Animal 的析构函数）？通过查看 animal 指向的对象的虚拟 table，为此 D0-析构函数包含在 vtable.

中

然而，这都是 g++ 的实现细节，我认为标准中没有太多强制这样做的内容。尽管如此，clang++ 的功能完全相同，但必须检查 MSVS 和 intel。

PS：关于 deleting destructors 的精彩文章。

在堆栈中创建对象时，即使代码覆盖率为 100%，函数覆盖率也较小

Function coverage is lesser even with 100% code coverage when objects created in the stack

c++

gcov

lcov