C++学习基础十——子类构造函数与析构函数的执行

1.子类构造函数的执行：

先执行父类的构造函数，再执行成员对象的构造函数，最后执行自身的构造函数。

当继承多个类时，构造函数的 执行顺序与继承时的顺序 相同，而与子类构造函数调用父类构造函数的顺序无关。

2.子类析构函数的执行：

先执行自身析构函数，再执行成员对象的析构函数，最后执行父类的析构函数 。

当继承多个类时，父类析构函数的执行过程与构造函数的执行过程相反

3.代码如下：

 #include <iostream>
 #include <string>

 using namespace std;
 //子类构造函数的执行过程：先执行父类的构造函数，再执行成员对象的构造函数，最后执行自身的构造函数
 //当继承多个类时，构造函数的 执行顺序与继承时的顺序 相同，而与子类构造函数调用父类构造函数的顺序无关
 //子类析构函数的执行过程：先执行自身析构函数，再执行成员对象的析构函数，最后执行父类的析构函数
 //当继承多个类时，父类析构函数的执行过程与构造函数的执行过程相反 

 class Base1
 {
 public:
     Base1(int k)
     {
         a = k;
         cout<<"Base1的构造函数被调用...."<<endl;
     }
     void test()
     {
         cout<<a<<endl;
     }
     ~Base1()
     {
         cout<<"Base1的析构函数被调用...."<<endl;
     }
 private:
     int a;
 };

 class Base2
 {
 public :
     Base2(int k)
     {
         b = k;
         cout<<"Base2的构造函数被调用...."<<endl;
     }
     void test()
     {
         cout<<b<<endl;
     }
     ~Base2()
     {
         cout<<"Base2的析构函数被调用...."<<endl;
     }
 private:
     int b;
 };

 class Base3
 {
 public:
     Base3()
     {
         c = ;
         cout<<"Base3的默认构造函数被调用...."<<endl;
     }
     void test()
     {
         cout<<c<<endl;
     }
     ~Base3()
     {
         cout<<"Base3的析构函数被调用...."<<endl;
     }
 private:
     int c;
 };

 class Demos
 {
 public:
     Demos(int k)
     {
         m = k;
         cout<<"Demos的构造函数被调用...."<<endl;
     }
     int getM()
     {
         return m;
     }
     ~Demos()
     {
         cout<<"Demos的析构函数被调用...."<<endl;
     }
 private:
     int m;
 };

 class son:public Base1,public Base3,public Base2
 {
 public:
     son(int a,int b,int c,int l);
     void test();
     ~son();
 private:
     int s;
     Demos d;
 };

 son::son(int a,int b,int c,int l):Base1(a),Base2(b),s(c),d(l)
 {
     cout<<"son的构造函数被调用...."<<endl;
 }

 void son::test()
 {
     Base1::test();
     Base2::test();
     Base3::test();
     cout<<s<<endl;
     cout<<d.getM()<<endl;
 }
 son::~son()
 {
     cout<<"son的析构函数被调用...."<<endl;
 }

 int main()
 {
     cout<<"======子类构造函数的执行过程    start====="<<endl;
     son son(,,,);
     cout<<"======子类构造函数的执行过程    end====="<<endl;
     son.test();

     cout<<"\n======子类析构函数的执行过程   ====="<<endl;
     return ;
 }

执行结果如下图所示：