类继承中的构造与析构

class A{
public:
    A(){
        int a = 0;
    };
    virtual ~A(){
        int a = 1;
    };
    virtual int test(){
        return 1;
    };
};
class B:public A{
public:
    B(){
        int a = 2;
    };
    virtual ~B(){
        int a = 3;
    };
    virtual int test(){
        return 2;
    };
};

执行以下操作：

A* p = new B;
delete p;
p->test();

根据我以前知道的知识，在new子类时，会先调用基类构造，再调用子类构造；在delete子类时，会先调用子类析构，再调用基类析构；

而在调用子类的虚函数test时，并不会在调用前或调用后自动调用基类的test函数。

为什么构造函数和析构函数如此特殊？这种自动调用的过程是如何实现的呢？

首先纠正一个错误：在执行new时我们可以观察到，程序会先执行基类A构造函数中的操作，再执行子类B构造函数中的操作，但这不代表先调用了A的构造，其后才调用的B的构造。

如果仔细观察汇编代码，可以发现main确确实实的call了 B::B()

mian():
        push    rbp
        mov     rbp, rsp
        push    rbx
        sub     rsp, 24
        mov     edi, 8
        call    operator new(unsigned long)
        mov     rbx, rax
        mov     rdi, rbx
        call    B::B() [complete object constructor]
        mov     QWORD PTR [rbp-24], rbx
        mov     rax, QWORD PTR [rbp-24]
        test    rax, rax
        je      .L12
        mov     rdx, QWORD PTR [rax]
        add     rdx, 8
        mov     rdx, QWORD PTR [rdx]
        mov     rdi, rax
        call    rdx

其实这个问题原因出在编译器在编译存在继承关系的类的构造与析构时的特殊对待：

在编译B的构造函数时，在处理完栈指针和参数后（参数可能是B对象的地址），会调用A的构造，此后再执行B构造中的操作。

B::B() [base object constructor]:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 32
        mov     QWORD PTR [rbp-24], rdi
        mov     rax, QWORD PTR [rbp-24]
        mov     rdi, rax
        call    A::A() [base object constructor]
        mov     edx, OFFSET FLAT:vtable for B+16
        mov     rax, QWORD PTR [rbp-24]
        mov     QWORD PTR [rax], rdx
        mov     DWORD PTR [rbp-4], 2
        nop
        leave
        ret

同样的，在编译B的析构函数时，在执行完整个函数准备ret前，会调用A的析构函数。

B::~B() [base object destructor]:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 32
        mov     QWORD PTR [rbp-24], rdi
        mov     edx, OFFSET FLAT:vtable for B+16
        mov     rax, QWORD PTR [rbp-24]
        mov     QWORD PTR [rax], rdx
        mov     DWORD PTR [rbp-4], 3
        mov     rax, QWORD PTR [rbp-24]
        mov     rdi, rax
        call    A::~A() [base object destructor]
        nop
        leave
        ret
B::~B() [deleting destructor]:
        push    rbp
        mov     rbp, rsp
        sub     rsp, 16
        mov     QWORD PTR [rbp-8], rdi
        mov     rax, QWORD PTR [rbp-8]
        mov     rdi, rax
        call    B::~B() [complete object destructor]
        mov     rax, QWORD PTR [rbp-8]
        mov     esi, 8
        mov     rdi, rax
        call    operator delete(void*, unsigned long)
        leave
        ret

结论

子类的构造与析构如此特殊在于编译器对它们的特殊处理，子类的构造函数在执行第一行语句前，会调用基类的构造函数；而子类的析构函数在执行完所有操作准备ret前，会调用基类的析构函数。

这也就导致我们能够观察到多重继承中的层层构造和层层析构，因为父类的构造（析构）已经被编译到子类的构造（析构）中，自然会有这样的调用顺序！甚至就算在子类的析构中插入return语句，都只会jmp到调用父类析构前的语句，而不是像普通函数一样直接ret。