复合&继承关系下的构造和析构

继承关系下的构造和析构

看一下测试代码：

/*
 * @filename:    Inheritance.cpp
 * @author:      Tanswer
 * @date:        2018年01月31日 14:59:28
 * @description: 测试继承关系下的构造和析构
 */

#include<iostream>
using namespace std;

class Base
{
    public:
        Base(){
            cout << "Base ctor ..." << endl;
        }
        virtual ~Base(){
            cout << "Base dtor ..." << endl;
        }
};

class Derived:public Base
{
    public:
        Derived(){
            cout << "Derived ctor ..." << endl;
        }
        ~Derived(){
            cout << "Derived dtor ..." << endl;
        }
};

int main()
{
    Derived test;

    return 0;
}

代码描述了这样一种关系，如下：

继承表现为 is-a 的关系，举个例子人是哺乳动物，那么人具有哺乳动物的特征，所以将 Base 放在里面。

运行结果如下：

1. 构造由内而外
   Derived 的构造函数首先调用 Base 的 default 构造函数，然后才执行自己的。
   代码类似这样：Derived::Derived(…): Base() { … }; 这是编译器加的，我们声明一个子类时不需要管。

2. 析构由外而内
   Derived 的析构函数首先执行自己，然后才调用 Base 的析构函数。
   代码类似这样：Derived::~Derived(…) { … ~Base() }; 同上。

复合关系下的构造和析构

看一下测试代码：

/*
 * @filename:    Composition.cpp
 * @author:      Tanswer
 * @date:        2018年01月31日 15:06:21
 * @description: 测试复合关系下的构造和析构
 */

#include<iostream>
using namespace std;

class Component
{
    public:
        Component(){
            cout << "Component ctor ..." << endl;
        }
        ~Component(){
            cout << "Component dtor ..." << endl;
        }
};

class Container
{
    public:
        Container(){
            cout << "Container ctor ..." << endl;
        }
        ~Container(){
            cout << "Container dtor ..." << endl;
        }
        Component c;
};


int main()
{
    Container test;
    return 0;
}

复合表现为 has-a 的关系，如下：

运行结果如下：

1. 构造由内而外
   Container 的构造函数首先调用 Component 的 default 构造函数，然后才执行自己的。
   代码类似这样：Container::Container(…): Component() { … };

2. 析构由外而内
   Container 的析构函数首先执行自己，然后才调用 Component 的析构函数。
   代码类似这样：Container::~Container(…) { … ~Component() }; 同上。

继承和复合关系下的构造和析构

那么既有继承，又有复合呢？构造和析构顺序是什么样呢？

测试代码如下：

/*
 * @filename:    Inheritance.cpp
 * @author:      Tanswer
 * @date:        2018年01月31日 14:59:28
 * @description: 测试继承复合关系下的构造和析构
 */

#include<iostream>
using namespace std;

class Component
{
    public:
        Component(){
            cout << "Component ctor ..." << endl;
        }
        ~Component(){
            cout << "Component dtor ..." << endl;
        }
};
class Base
{
    public:
        Base(){
            cout << "Base ctor ..." << endl;
        }
        virtual ~Base(){
            cout << "Base dtor ..." << endl;
        }
        int n;
};

class Derived:public Base
{
    public:
        Derived(){
            cout << "Derived ctor ..." << endl;
        }
        ~Derived(){
            cout << "Derived dtor ..." << endl;
        }
        Component c;
};

int main()
{
    Derived test;

    return 0;
}

按照前面两种情况下的讨论，可以得到它们的关系如下：

问题在于里面部分的次序，谁先谁后，在我目前的环境下，运行结果如下：

也就是：

1. 构造由内而外
   Derived 的构造函数首先调用 Base 的 default 构造函数，然后调用 Component 的 default 构造函数，然后才执行自己的。
   代码类似这样：Derived::Derived(…): Base() , Component() { … };

2. 析构由外而内
   Derived 的析构函数首先执行自己，然后调用 Component 的析构函数，然后调用 Base 的析构函数。
   代码类似这样：Derived::~Derived(…) { … ~Component(), ~Base() }; 。

有疑问的可以自己测试一下，在析构和构造函数里打印点文字，来验证一下。其实也很好想，构造时从里面一层一层往外构造，拆除时肯定要从外面开始，一层一层的拆掉。