本文共 2997 字，大约阅读时间需要 9 分钟。

继承关系下的构造和析构

看一下测试代码：

/* * @filename:    Inheritance.cpp * @author:      Tanswer * @date:        2018年01月31日 14:59:28 * @description: 测试继承关系下的构造和析构 */#include
   
    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
   
    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
   
    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() }; 。

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