1、构造函数的调用顺序
基类构造函数、对象成员构造函数、派生类本身的构造函数
2、析构函数的调用顺序
派生类本身的析构函数、对象成员析构函数、基类析构函数（与构造顺序相反）
析构函数在下边3种情况时被调用：
1.对象生命周期结束，被销毁时(一般类成员的指针变量与引用都i不自动调用析构函数)；
2.delete指向对象的指针时，或delete指向对象的基类类型指针，而其基类虚构函数是虚函数时；
3.对象i是对象o的成员，o的析构函数被调用时，对象i的析构函数也被调用。
#include "iostream"using namespace std;class Base{public:Base(){ std::cout<<"Base::Base()"<<std::endl; }~Base(){ std::cout<<"Base::~Base()"<<std::endl; }};class Base1:public Base{public:Base1(){ std::cout<<"Base1::Base1()"<<std::endl; }~Base1(){ std::cout<<"Base1::~Base1()"<<std::endl; }};class Derive{public:Derive(){ std::cout<<"Derive::Derive()"<<std::endl; }~Derive(){ std::cout<<"Derive::~Derive()"<<std::endl; }};class Derive1:public Base1{private:Derive m_derive;//声明一个Derive类的对象m_derivepublic:Derive1(){ std::cout<<"Derive1::Derive1()"<<std::endl; }~Derive1(){ std::cout<<"Derive1::~Derive1()"<<std::endl; }};int main(){Derive1 derive;return 0;}
构造函数的调用顺序是；首先，如果存在基类，那么先调用基类的构造函数，如果基类的构造函数中仍然存在基类，那么程序会继续进行向上查找，直到找到它最早的基类进行初始化；如上例中类Derive1，继承于类Base与Base1；其次，如果所调用的类中定义的时候存在着对象被声明，那么在基类的构造函数调用完成以后，再调用对象的构造函数，如上例中在类Derive1中声明的对象Derive m_derive；最后，将调用派生类的构造函数，如上例最后调用的是Derive1类的构造函数。
包含对象成员的类的构造与析构顺序
class A { public: A() { cout << "A's constructor." << endl; } ~A() { cout << "A's destructor." << endl; } }; class B { public: B() { cout << "B's constructor." << endl; } ~B() { cout << "B's destructor." << endl; } }; class C { private: B bInC; public: C() { cout << "C's constructor." << endl; } ~C() { cout << "C's destructor." << endl; } A aInC; }; class D:public C { public: D() { cout << "D's constructor." << endl; } ~D() { cout << "D's destructor." << endl; } A aInD; private: B bInD; }; int main(void) { D d; return 0; }
输出结果：
B's constructor. A's constructor. C's constructor. A's constructor. B's constructor. D's constructor. D's destructor. B's destructor. A's destructor. C's destructor. A's destructor. B's destructor.
分析如下：
（1）存在继承关系时，先执行父类的构造函数，再执行子类的构造函数；
（2）当一个类中含有对象成员时，在启动本类的构造函数之前，先分配对象空间，按对象成员的声明顺序执行他们各自的构造函数，再继续执行本类的构造函数；
（3）对于非静态的局部对象，他们的析构函数的执行顺序与构造函数相反。
在本程序中：
（1）执行main()，需要创建一个对象d，所以，需要执行D的构造函数。而D继承自C，所以先要执行C的构造函数；
（2）而在C中存在对象成员bInC和aInC，所以，在C的构造函数执行之前，先按声明顺序执行B和A的构造函数，然后执行C的构造函数；
（3）轮到构造d了，但是D中有对象成员aInD和bInD，所以，在D的构造函数执行之前，先按声明顺序执行A和B的构造函数，最后，执行D的构造函数；
（4）以上所有对象的析构函数以与构造函数的执行顺序相反的顺序执行。
virtual析构函数
在C++中，构造函数不能声时为虚函数，这是因为编译器在构造对象时，必须知道确切类型，才能正确的生成对象，因此，不允许使用动态束定；其次，在构造函数执行之前，对象并不存在，无法使用指向此此对象的指针来调用构造函数，然而，析构函数是可以声明为虚函数；C++明白指出，当derived class对象经由一个base class指针被删除，而该base class带着一个non-virtual析构函数，其结果未有定义—实际执行时通常发生的是对象的derived成分没被销毁掉。
看下面的例子：
class Base{public:Base(){ std::cout << "Base::Base()" << std::endl; }~Base(){ std::cout << "Base::~Base()" << std::endl; }};class Derive :public Base{public:Derive(){ std::cout << "Derive::Derive()" << std::endl; }~Derive(){ std::cout << "Derive::~Derive()" << std::endl; }};int main(){Base* pBase = new Derive();//这种base classed的设计目的是为了用来"通过base class接口处理derived class对象"delete pBase;return 0;}
从上面的输出结果可以看出，析构函数的调用结果是存在问题的，也就是说析构函数只作了局部销毁工作，这可能形成资源泄漏败坏数据结构等问题；那么解决此问题的方法很简单，给base class一个virtual析构函数；
class Base{public:Base(){ std::cout<<"Base::Base()"<<std::endl; }virtual ~Base(){ std::cout<<"Base::~Base()"<<std::endl; }};class Derive:public Base{public:Derive(){ std::cout<<"Derive::Derive()"<<std::endl; }~Derive(){ std::cout<<"Derive::~Derive()"<<std::endl; }};int _tmain(int argc, _TCHAR* argv[]){Base* pBase = new Derive();delete pBase;return 0;}
由此还可以看出虚函数还是多态的基础，在C++中没有虚函数就无法实现多态特性；因为不声明为虚函数就不能实现“动态联编”，所以也就不能实现多态啦！
