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

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