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

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

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

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

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

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

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

3.代码如下：

  1 #include <iostream>
  2 #include <string>
  3
  4 using namespace std;
  5 //子类构造函数的执行过程：先执行父类的构造函数，再执行成员对象的构造函数，最后执行自身的构造函数
  6 //当继承多个类时，构造函数的 执行顺序与继承时的顺序 相同，而与子类构造函数调用父类构造函数的顺序无关
  7 //子类析构函数的执行过程：先执行自身析构函数，再执行成员对象的析构函数，最后执行父类的析构函数
  8 //当继承多个类时，父类析构函数的执行过程与构造函数的执行过程相反
  9
 10 class Base1
 11 {
 12 public:
 13     Base1(int k)
 14     {
 15         a = k;
 16         cout<<"Base1的构造函数被调用...."<<endl;
 17     }
 18     void test()
 19     {
 20         cout<<a<<endl;
 21     }
 22     ~Base1()
 23     {
 24         cout<<"Base1的析构函数被调用...."<<endl;
 25     }
 26 private:
 27     int a;
 28 };
 29
 30 class Base2
 31 {
 32 public :
 33     Base2(int k)
 34     {
 35         b = k;
 36         cout<<"Base2的构造函数被调用...."<<endl;
 37     }
 38     void test()
 39     {
 40         cout<<b<<endl;
 41     }
 42     ~Base2()
 43     {
 44         cout<<"Base2的析构函数被调用...."<<endl;
 45     }
 46 private:
 47     int b;
 48 };
 49
 50 class Base3
 51 {
 52 public:
 53     Base3()
 54     {
 55         c = 0;
 56         cout<<"Base3的默认构造函数被调用...."<<endl;
 57     }
 58     void test()
 59     {
 60         cout<<c<<endl;
 61     }
 62     ~Base3()
 63     {
 64         cout<<"Base3的析构函数被调用...."<<endl;
 65     }
 66 private:
 67     int c;
 68 };
 69
 70 class Demos
 71 {
 72 public:
 73     Demos(int k)
 74     {
 75         m = k;
 76         cout<<"Demos的构造函数被调用...."<<endl;
 77     }
 78     int getM()
 79     {
 80         return m;
 81     }
 82     ~Demos()
 83     {
 84         cout<<"Demos的析构函数被调用...."<<endl;
 85     }
 86 private:
 87     int m;
 88 };
 89
 90 class son:public Base1,public Base3,public Base2
 91 {
 92 public:
 93     son(int a,int b,int c,int l);
 94     void test();
 95     ~son();
 96 private:
 97     int s;
 98     Demos d;
 99 };
100
101 son::son(int a,int b,int c,int l):Base1(a),Base2(b),s(c),d(l)
102 {
103     cout<<"son的构造函数被调用...."<<endl;
104 }
105
106 void son::test()
107 {
108     Base1::test();
109     Base2::test();
110     Base3::test();
111     cout<<s<<endl;
112     cout<<d.getM()<<endl;
113 }
114 son::~son()
115 {
116     cout<<"son的析构函数被调用...."<<endl;
117 }
118
119 int main()
120 {
121     cout<<"======子类构造函数的执行过程    start====="<<endl;
122     son son(1,2,3,4);
123     cout<<"======子类构造函数的执行过程    end====="<<endl;
124     son.test();
125
126     cout<<"\n======子类析构函数的执行过程   ====="<<endl;
127     return 0;
128 }

执行结果如下图所示：