当我使用 gcov 来测量 C++ 代码的测试覆盖率时，它会报告析构函数中的分支。

struct Foo
{
    virtual ~Foo()
    {
    }
};

int main (int argc, char* argv[])
{
    Foo f;
}

$ gcov /home/epronk/src/lcov-1.9/example/example.gcda -o /home/epronk/src/lcov-1.9/example -b
File 'example.cpp'
Lines executed:100.00% of 6
Branches executed:100.00% of 2
Taken at least once:50.00% of 2
Calls executed:40.00% of 5
example.cpp:creating 'example.cpp.gcov'

$ cat example.cpp.gcov | c++filt
        -:    0:Source:example.cpp
        -:    0:Graph:/home/epronk/src/lcov-1.9/example/example.gcno
        -:    0:Data:/home/epronk/src/lcov-1.9/example/example.gcda
        -:    0:Runs:1
        -:    0:Programs:1
        -:    1:struct Foo
function Foo::Foo() called 1 returned 100% blocks executed 100%
        1:    2:{
function Foo::~Foo() called 1 returned 100% blocks executed 75%
function Foo::~Foo() called 0 returned 0% blocks executed 0%
        1:    3:    virtual ~Foo()
        1:    4:    {
        1:    5:    }
branch  0 taken 0% (fallthrough)
branch  1 taken 100%
call    2 never executed
call    3 never executed
call    4 never executed
        -:    6:};
        -:    7:
function main called 1 returned 100% blocks executed 100%
        1:    8:int main (int argc, char* argv[])
        -:    9:{
        1:   10:    Foo f;
call    0 returned 100%
call    1 returned 100%
        -:   11:}

最佳答案

在典型的实现中，析构函数通常有两个分支:一个用于非动态对象销毁，另一个用于动态对象销毁。特定分支的选择是通过调用者传递给析构函数的隐藏 bool 参数来执行的。它通常作为 0 或 1 通过寄存器传递。

我猜想，因为在你的情况下，破坏是针对非动态对象的，所以不采用动态分支。尝试添加 new -ed 然后 delete -ed 类的对象 Foo并且第二个分支也应该被采用。

这种分支的必要性源于 C++ 语言的规范。当某个类定义了自己的 operator delete ，具体选择operator delete调用就像从类析构函数内部查找一样完成。最终结果是对于具有虚拟析构函数的类 operator delete表现得好像它是一个虚函数(尽管正式是类的静态成员)。

许多编译器从字面上实现了这种行为:正确的 operator delete直接从析构函数实现内部调用。当然，operator delete只应在销毁动态分配的对象时调用(不适用于本地或静态对象)。为此，请调用 operator delete被放置到由上述隐藏参数控制的分支中。

在您的示例中，事情看起来很简单。我希望优化器删除所有不必要的分支。然而，它似乎以某种方式设法在优化中幸存下来。

这里有一些额外的研究。考虑这个代码

#include <stdio.h>

struct A {
  void operator delete(void *) { scanf("11"); }
  virtual ~A() { printf("22"); }
};

struct B : A {
  void operator delete(void *) { scanf("33"); }
  virtual ~B() { printf("44"); }
};

int main() {
  A *a = new B;
  delete a;
} 

__ZN1AD2Ev:                      ; destructor A::~A  
LFB8:
        pushl   %ebp
LCFI8:
        movl    %esp, %ebp
LCFI9:
        subl    $8, %esp
LCFI10:
        movl    8(%ebp), %eax
        movl    $__ZTV1A+8, (%eax)
        movl    $LC1, (%esp)     ; LC1 is "22"
        call    _printf
        movl    $0, %eax         ; <------ Note this
        testb   %al, %al         ; <------ 
        je      L10              ; <------ 
        movl    8(%ebp), %eax    ; <------ 
        movl    %eax, (%esp)     ; <------ 
        call    __ZN1AdlEPv      ; <------ calling `A::operator delete`
L10:
        leave
        ret

__ZN1AD0Ev:                      ; another destructor A::~A       
LFB10:
        pushl   %ebp
LCFI13:
        movl    %esp, %ebp
LCFI14:
        subl    $8, %esp
LCFI15:
        movl    8(%ebp), %eax
        movl    $__ZTV1A+8, (%eax)
        movl    $LC1, (%esp)     ; LC1 is "22"
        call    _printf
        movl    $1, %eax         ; <------ See the difference?
        testb   %al, %al         ; <------
        je      L14              ; <------
        movl    8(%ebp), %eax    ; <------
        movl    %eax, (%esp)     ; <------
        call    __ZN1AdlEPv      ; <------ calling `A::operator delete`
L14:
        leave
        ret

关于c++ - gcov 报告的析构函数中的分支是什么？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/7199360/