C++析构和构造函数执行顺序(继承和内嵌成员对象)

结论:C++处理多个对象、以及成员对象和继承时，构造函数的执行顺序与析构顺序相反。也就是先调用构造函数的对象，会后调用析构函数，有点像栈的先入后出。

例子1：封闭类和成员对象

  1、定义：一个类的成员变量是另一个类的对象，则称该成员变量为内嵌成员对象，包含成员对象的类为封闭类。

  2.此时的封闭类和成员对象是 包含(从属)关系，也就是封闭类有(has)成员对象。 例如计算机包含中央处理器和内存等等，计算机类是一个封闭类，cpu类的对象在计算机类里做成员对象。

  3.例如下面的简单案例：

#include
using namespace std;
class MyCpu { //cpu类
public:
MyCpu() { cout << "MyCpu constructor" << endl; }
~MyCpu() { cout << "MyCpu destructor" << endl; }
};
class MyMemory { //内存类
public:
MyMemory(){ cout << "MyMemory constructor" << endl; }
~MyMemory() { cout << "MyMemory destructor" << endl; }
};
class MyComputer { //计算机类：封闭类
public:
MyComputer() {
cout << "MyComputer constructor" << endl;
}
~MyComputer() { cout << "MyComputer destructor" << endl; }
private:
MyCpu cpu_; //内嵌成员对象
MyMemory mem_;
};
void test01() {
MyComputer myCom;
}
int main() {
test01();
return 0;
}


  4.分析：首先会调用成员对象的构造函数，再调用封闭类的构造函数；析构时先调用封闭类的析构函数，再调用成员对象的析构函数。

例子2：继承时基类与派生类

  1.继承时，基类与派生类的关系为：具体类是一个抽象类的关系，即A是(is)一个B。例如抽象类是人类，具体类是学生类，某个学生是一个人。

  2.简单例子:

#include
using namespace std;
//C++处理顺序一般规律：先构造的后析构，类似于栈。
//先调用基类的构造，先调用派生类的析构
class MyBase { //基类
public:
MyBase(int b=0) :b_(b) {
cout << "MyBase constructor" << endl;
}
~MyBase(){ cout << "MyBase destructor" << endl; }
private:
int b_;
};
class MyDerive: public MyBase{ //派生类
public:
MyDerive(int b=0, int d=0)
:MyBase(b), d_(d)
{
cout << "MyDerive constructor" << endl;
}
~MyDerive() { cout << "MyDerive destructor" << endl; }
private:
int d_;
};
int main() {
MyDerive der;
return 0;
}


  3.分析：首先会基类的构造函数，再调用派生类的构造函数；析构时先调用派生类的析构函数，再调用基类的析构函数。

  细节补充：采用初始化列表来解决基类成员和内嵌成员对象的初始化。因为子类不会继承父类的构造器和析构器，所以子类新增自己的非成员对象的普通变量在子类的构造函数里初始化，父类成员变量的初始化需要父类的构造函数进行初始化。

派生类构造函数名(总形参列表)
:基类构造函数名(基类构造函数实参表)，内嵌成员对象名(成员对象的构造函数实参)
{
派生类普通变量初始化；//不嫌长的话，也可以放到初始化列表
}