窥视C++细节-父类为什么要虚析构

本文将分析，父类的析构函数为什么必须为虚函数，如果不是虚函数会造成什么问题？在没有使用多态时，是否还需要将父类的析构器置为虚函数？同时也会分析多继承下的虚析构问题。

环境

https://godbolt.org/，这个网站可以方便的将C++代码编译成汇编，同时使用颜色标识某条C++语句对应的汇编代码。

在使用之前需要可以根据自己的习惯配置一下。

使用的gcc版本是10.2

-m32：将C++代码编译成32位的汇编

-O0：不要进行编译优化

Intel asm syntax：编译成intel格式的汇编，默认是AT&T格式的汇编。

Demangle identifiers：反命名倾轧，在汇编代码中使用C++中函数的名字，这样更便于阅读。

单继承下的虚析构

析构的顺序

一般情况下，当子类对象离开作用域或被delete时，会调用子类的析构器，在子类析构器处理完成后，会继续调用父类的析构器。

class A
{
public:
    ~A(){
        cout<<"~A()"<<endl;
    }
};

class B : public A
{
public:
    ~B(){
        cout<<"~B()"<<endl;
    }
};

int main()
{
    B * pb = new B;

    delete pb;

    return 0;
}

~B()
~A()

虽然我们没有显式的在类B的析构器中调用类A的析构器，但这个工作由编译器做了。

在汇编代码中，我们可以清楚的看到编译器在~B()中帮助编写了调用~A()的代码。

子类没有发生析构

正常的析构流程中，子类和父类的析构器都会被调用，析构是完整的。

当销毁子类对象时，若子类的析构器或父类的析构器没有被调用，则析构是不完整的，这有可能会造成资源的泄露，这是不被允许的。

class A
{
public:
    ~A(){
        cout<<"~A()"<<endl;
    }
};

class B : public A
{
public:
    ~B(){
        cout<<"~B()"<<endl;
    }
};

int main()
{
    B * pb = new B;

    A * pa = pb;
    
    delete pa;

    return 0;
}

~A()

将子类的指针赋值给父类的指针，是可以的，称为赋值兼容，这也是形成多态的基础。

但在通过父类指针销毁子类对象时候，子类的析构器没有被调用。

因为父类的析构器不是虚函数，所以父类在调用析构时，调用的就是父类的构造器，所以子类的析构器没有被调用。

因为类B析构器没有被使用，所以~B(){}被优化掉了。

随意的定义了一个类B对象，这样~B()将会被使用，所以没有被编译器优化掉。

虽然~B()的汇编代码存在了，但是delete pa时，~B()还是没有被调用。

将父类析构器置为虚函数

class A
{
public:
    virtual ~A(){
        cout<<"~A()"<<endl;
    }
};

class B : public A
{
public:
    ~B(){
        cout<<"~B()"<<endl;
    }
};

int main()
{
    B * pb = new B;

    A * pa = pb;

    delete pa;

    return 0;
}

~B()
~A()

因为父类的析构函数是虚函数，且父类的指针指向了子类对象，所以父类在调用析构函数时，会调用子类的析构函数，编译器会在子类的析构函数中安插调用父类析构函数的代码，所以当子类对象的析构函数处理完后，父类的析构函数也会调用。这样一来，子类和父类的析构函数全都会被调用，析构完整。

如果一个类中有虚函数，那么这个类的对象的前四个字节是指向虚函数表的指针。

现在的状态如上图，现在分析一个delete pa的过程。

        #[ebp-16]就是变量 pa，现在将指针存放到eax寄存器
        mov     eax, DWORD PTR [ebp-16]    
        test    eax, eax        #测试eax是否为空
        je      .L8             #如果eax为空，直接跳转到.L8:处执行。
        mov     edx, DWORD PTR [eax]    #[eax]指向类B的虚函数表
        add     edx, 4                  #指向虚函数表的第二个虚函数
        mov     edx, DWORD PTR [edx]    #获取第二个虚函数的地址
        sub     esp, 12
        push    eax                     #压入this，作为调用虚函数的参数。
        call    edx                     #调用虚函数表中第二个虚函数
        add     esp, 16
.L8:   #执行到这里说明pa为nullptr，那么不需要delete。
        mov     eax, 0
        lea     esp, [ebp-8]
        pop     ecx
        pop     ebx
        pop     ebp
        lea     esp, [ecx-4]
        ret

这段代码就是delete pa对应的汇编

多继承下的虚析构

this指针的调整

class A
{
public:
    A(){
        cout<<"A this = "<<this<<endl;
    }
private:
    int i;
    float f;
};

class B
{
public:
    B(){
        cout<<"B this = "<<this<<endl;
    }
private:
    int bb;
};

class C : public A, public B
{
public:
    C(){
        cout<<"C this = "<<this<<endl;
    }
private:
    int cc;
};

int main()
{
    C c;

    cout<<"&c = "<<&c<<endl;

    return 0;
}

A this = 0x7fffdf3e9670
B this = 0x7fffdf3e9678
C this = 0x7fffdf3e9670
&c = 0x7fffdf3e9670

我们会发现父类B的this指针和其他指针有些不一样，其内存布局如下图：

所以在类B内拿到的this指针和从A中、C中拿到的指针是不一样的，同时也可以看出A、C中的this和&c是一样的，都是指向对象的起始地址。

多继承下的虚析构原理

class A
{
public:
    virtual ~A(){
        cout<<"~A()"<<endl;
    }
private:
    int i;
    float f;
};

class B
{
public:
    virtual ~B(){
        cout<<"~B()"<<endl;
    }
private:
    int bb;
};

class C : public A, public B
{
public:
    ~C(){
        cout<<"~C()"<<endl;
    }
private:
    int cc;
};

int main()
{
    C *pc = new C;

    B * pb = pc;

    delete pb;

    return 0;
}

~C()
~B()
~A()

delete pb需要做两件事情，先是调用类B的析构器，因为类B的析构器是虚函数，恰好此时pb指向的是子类，所以形成多态，那么就会调用子类的析构器，在子类的析构器处理完毕后，会依次调用类B的析构器和类A的析构器，这个确实没有什么问题；另一件事是需要将new出的整个类C对象的空间释放掉，不太好办的地方是，在类B中的this不是指向类C对象的起始位置，所以无法直接使用类B的this释放该堆空间。

此时编译器在内部安插了代码，在delete pb的时候，将调整this的值，使其指向类对象的起始位置，这样在释放堆空间的时候就没有问题了。