C++ 构造，析构顺序(静态对象)

测试代码：

#include <iostream>
#include <cstdlib>
using namespace std;
class A{
    public:
        A(){
            cout<<"A - 构造"<<endl;
        }
        ~A(){
            cout<<"A - 析构"<<endl;
        }
};
class B:public A{
    public:
        B(){
            cout<<"B - 构造"<<endl;
        }
        ~B(){
            cout<<"B - 析构"<<endl;
        }
};
class C{
    public:
        C(){
            cout<<"C - 构造"<<endl;
        }
        ~C(){
            cout<<"c - 析构"<<endl;
        }
};
class E{
    public:
        E(){
            cout<<"e - 构造"<<endl;
        }
        ~E(){
            cout<<"E - 析构"<<endl;
        }
};
class D:public E{
    public:
        D(){
            cout<< "D - 构造"<<endl;
        }
        ~D(){
            cout<< "D - 析构"<<endl;
        }
    private:
    C c;
    static B b;
};
B D::b;
int main()
{
    D d;
    cout << "Hello world!" << endl;
    return 0;
}

运行结果如下：

分析：在一个类中，如果存在其他类的成员，先进行构造，若这个类对象是static的，静态对象是在所有其他对象之前进行构造，若这个静态对象要是继承某个父类，应先构造父类，在构造派生类，所以 A - 构造；B - 构造；e - 构造（构造自己的父类）；c - 构造 ；最后才是 D - 构造；

析构的顺序与其相反 进行，静态函数最后 析构。

测试代码：不带static对象：

#include <iostream>
#include <cstdlib>
using namespace std;
class A{
    public:
        A(){
            cout<<"A - 构造"<<endl;
        }
        ~A(){
            cout<<"A - 析构"<<endl;
        }
};
class B:public A{
    public:
        B(){
            cout<<"B - 构造"<<endl;
        }
        ~B(){
            cout<<"B - 析构"<<endl;
        }
};
class C{
    public:
        C(){
            cout<<"C - 构造"<<endl;
        }
        ~C(){
            cout<<"c - 析构"<<endl;
        }
};
class E{
    public:
        E(){
            cout<<"e - 构造"<<endl;
        }
        ~E(){
            cout<<"E - 析构"<<endl;
        }
};
class D:public E{
    public:
        D(){
            cout<< "D - 构造"<<endl;
        }
        ~D(){
            cout<< "D - 析构"<<endl;
        }
    private:
    C c;
    B b;
};
//B D::b;
int main()
{
    D d;
    cout << "Hello world!" << endl;
    return 0;
}

结果如下：

不带有static对象，先构造自己的父类（若存在），然后构造里面的成员，c - 构造；B - 构造（A 是父类先构造），最后是自己的构造函数 D - 构造；析构函数与其相反；

总结：析构顺序：

1 先执行函数体的析构

2 然后按照声明顺续相反的执行所有非静态对象的析构

3 执行自己的父析构

4 若有静态成员对象，则最后析构

构造顺序：

1.先构造自己的父类，若是有静态成员对象，最先构造静态成员对象的父类，然后是静态成员对象，在其次是自己父类构造

2.其他非静态成员对象的构造

3.自己的构造函数