构造函数与析构函数分析

#include <iostream>
#include <string.h>
using namespace std;

class B {
public:
    B(int i){cout<<"B
";};
    ~B(){cout<<"~B
";};
};

class C {
public:
    C(int i){cout<<"C
";};
    ~C(){cout<<"~C
";};
};

class A {
public:
    A():b(1),c(1)
    {cout<<"A
";};
    ~A(){cout<<"~A
";}
    C c;
    B b;
};

int main()
{
    A a1;
}

　　试验代码如上。

输出结果如下：

C

B

A

~A

~B

~C

为什么调用构造函数的时候先调用C，然后B，最后才调用A呢？而调用函数析构正好相反呢？

我用现实中的一个例子来说吧，假如我现在要建一个楼房A，那么建好A之前，是不是首先得建好窗户B和门C，只有窗户B和门C建好后，楼房A才算完工。

相反，拆房的时候，我首先是把A拆了，然后再去捣鼓B和C。

#include <iostream>

usingnamespacestd;

 

 

class A

{

public:

    A()

    {

        cout<<"A ";

    }

    virtual void func()

    {

        cout<<"A::func ";

    }

    virtual void func1()

    {

        cout<<"A::func1 ";

    }

    ~A(){

        cout<<"A析构"<<endl;

    }

};

 

class B : publicA

{

public:

    B()

    {

        cout<<"B ";

        func();

    }

    void func1()                    //覆盖

    {

        cout<<"B::func ";

    }

    ~B(){

        cout<<"B析构"<<endl;

    }

};

 

 

int  main(void )

{

    A *a = new B();  //A B A::func

    a->func();       //A::func

    a->func1();       //B::func

    B b;               //A B A::func

    b.func();        //A::func

                       //B析构

                      //A析构

}     

　　而上面的这个例子又是另外一种情况，类B公有继承类A，那么B如果创建一个对象必须得先调用父类A的构造函数，而调用结束后，先析构B后析构A。