构造函数与析构函数的调用顺序

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++中没有虚函数就无法实现多态特性；因为不声明为虚函数就不能实现“动态联编”，所以也就不能实现多态啦！