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 = 0;
        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(1,2,3,4);
    cout<<"======子类构造函数的执行过程    end====="<<endl;
    son.test();
    
    cout<<"
======子类析构函数的执行过程   ====="<<endl;
    return 0;
}

执行结果如下图所示：