C++中多态中构造函数与析构函数的调用

做个实验，看一下成员变量的构造析构，父类子类的构造析构，以及虚函数对调用的影响。

 #include <iostream>
 using namespace std;

 class Member
 {
 public:
     Member(int n):m_n1(n)
     {
         cout<<"Member::Member("<<m_n1<<")"<<endl;
     }
     ~Member()
     {
         cout<<"Member::~Member("<<m_n1<<")"<<endl;
     }
 private:
     const int m_n1;
 };

 class Base
 {
 public:
     Base():m_m1()
     {
         cout<<"Base::Base()"<<endl;
         OnConstruct();
     }
     ~Base() //这里目前不是虚函数
     {
         cout<<"Base::~Base()"<<endl;
         OnDistruct();
     }
     virtual void OnConstruct()
     {
         cout<<"Base::OnConstruct()"<<endl;
     }
     virtual void OnDistruct()
     {
         cout<<"Base::OnDistruct()"<<endl;
     }
     virtual void Foo1()
     {
         cout<<"Base::Foo1()"<<endl;
     }
     void Foo2()
     {
         cout<<"Base::Foo2()"<<endl;
     }

 private:
     Member m_m1;//这是个类对象
 };

 class Drived:public Base
 {
 public:
     Drived():m_m2()
     {
         cout<<"Drived::Drived()"<<endl;
         OnConstruct();
     }
     ~Drived()
     {
         cout<<"Drived::~Drived()"<<endl;
         OnDistruct();
     }
     virtual void OnConstruct()
     {
         cout<<"Drived::OnConstruct()"<<endl;
     }
     virtual void OnDistruct()
     {
         cout<<"Drived::OnDistruct()"<<endl;
     }
     virtual void Foo1()
     {
         cout<<"Drived::Foo1()"<<endl;
     }
     void Foo2()//这个不是虚函数
     {
         cout<<"Drived::Foo2()"<<endl;
     }
 private:
     Member m_m2;//这是个类对象
 };

 int main(int argc, char *argv[])
 {
     Base* p = new Drived;
     p->Foo1();
     p->Foo2();
     delete p;
     return ;
 }

这段代码的运行输出为：

 Member::Member()  //父类的初始化列表被执行
 Base::Base()       //父类构造
 Base::OnConstruct()//父类构造中只会调用父类的函数。父类构造完毕
 Member::Member()    //子类构造的初始化列表
 Drived::Drived()     //子类构造
 Drived::OnConstruct()//子类构造中只会调用子类的函数。子类构造完毕
 Drived::Foo1()//发生多态，调用子类重写的函数
 Base::Foo2()  //未多态，调用父类版本的函数
 Base::~Base()     //父类开始析构
 Base::OnDistruct()//父类析构只会调用父类中的函数
 Member::~Member()//父类成员反初始化

同学们可以看到，子类的析构没有被执行，怎么让它能值执行呢？把父类的析构修饰为virtual即可：

     ~Base() //这里目前不是虚函数

这样在执行一遍，可以看到结果如果（注释出来的是新增的输出）：

 Member::Member()
 Base::Base()
 Base::OnConstruct()
 Member::Member()
 Drived::Drived()
 Drived::OnConstruct()
 Drived::Foo1()
 Base::Foo2()
 Drived::~Drived()   //子类析构，在父类之前执行
 Drived::OnDistruct()//子类析构只会调用子类的函数
 Member::~Member()  //子类成员反初始化
 Base::~Base()
 Base::OnDistruct()
 Member::~Member()

小结一下：

通过父类指针指向子类对象实现多态。

多态的时候，父类析构修饰为虚函数，以保证子类析构被调用。

构造顺序是：先父类后子类（这是最主要流程，后两条都再此前提下）；初始化列表在构造前执行；构造函数中值调用本类的函数（无论是否为虚函数）。

析构顺序是：先子类后父类（注意虚析构）；析构中只调用本类的函数；本类析构后再析构初始化列表中的成员。