我们知道构造函数的顺序是：
1.基类构造函数（基类子对象的成员里如果有类类型的成员，先调用类类型成员的构造函数，再调用基类的构造函数）
2.派生类的类类型成员的构造函数
3.派生类的构造函数
对于多继承：基类构造函数被调用的顺序以类派生表中声明的顺序为准
如class Panda:public Bear,public Endangered{};
先构造Bear,再构造Endangered，再构造Panda;
析构的顺序和构造的相反；
考虑下面的例子
Example 1:
class C{
public:
C(){cout<<"This is C Constructor"< ~C(){cout<<"This is C Destructor"< };
class A{
public:
A(){
cout<<"This is A Constructor"< }
// void print(int a){cout<<"This is C Des"<
C c;
~A(){
cout<<"This is A Destructor"< }
};
class B: public A,public C{
public:
B(){cout<<"This is B Constructor"< ~B(){cout<<"This is B Destructor"<};
int main()
{
A *a=new B;
delete a;
system("PAUSE");
return EXIT_SUCCESS;
}
输出：
This is C Constructor
This is A Constructor
This is C Constructor
This is B Constructor
This is A Destructor
This is C Destructor
没有完全被析出来
##########################################################################################
Example 2:
class C{
public:
C(){cout<<"This is C Constructor"< ~C(){cout<<"This is C Destructor"< };
class A{
public:
A(){
cout<<"This is A Constructor"< }
// void print(int a){cout<<"This is C Des"<
C c;
virtual ~A(){
cout<<"This is A Destructor"< }//多了个virtual
};
class B: public A,public C{
public:
B(){cout<<"This is B Constructor"< ~B(){cout<<"This is B Destructor"<};
int main()
{
A *a=new B;
delete a;
system("PAUSE");
return EXIT_SUCCESS;
}
输出：
This is C Constructor
This is A Constructor
This is C Constructor
This is B Constructor
This is B Destructor
This is C Destructor
This is A Destructor
This is C Destructor
完全被析出来了~
Example 3:
class C{
public:
C(){cout<<"This is C Constructor"< ~C(){cout<<"This is C Destructor"< };
class A{
public:
A(){
cout<<"This is A Constructor"< }
// void print(int a){cout<<"This is C Des"<
C c;
~A(){
cout<<"This is A Destructor"< }
};
class B: public A,public C{
public:
B(){cout<<"This is B Constructor"< ~B(){cout<<"This is B Destructor"<
// virtual ~B(){cout<<"This is B Destructor"<
};
int main()
{
B *a=new B;
delete a;
system("PAUSE");
return EXIT_SUCCESS;
}
输出：
This is C Constructor
This is A Constructor
This is C Constructor
This is B Constructor
This is B Destructor
This is C Destructor
This is A Destructor
This is C Destructor
这个是很自然的，因为
B *a=new B;
delete a;
Example 4:class C{
public:
C(){cout<<"This is C Constructor"< virtual ~C(){cout<<"This is C Destructor"< };
class A{
public:
A(){
cout<<"This is A Constructor"< }
// void print(int a){cout<<"This is C Des"<
C c;
virtual ~A(){
cout<<"This is A Destructor"< }
};
class B: public A,public C{
public:
B(){cout<<"This is B Constructor"< ~B(){cout<<"This is B Destructor"<};
int main()
{
C*a=new B;
delete a;
system("PAUSE");
return EXIT_SUCCESS;
}
结果同Example 2:
This is C Constructor
This is A Constructor
This is C Constructor
This is B Constructor
This is B Destructor
This is C Destructor
This is A Destructor
This is C Destructor
小结论：
一般规则 将根基类的析构函数声明为虚拟的，这样就能将所有的基类子对象释放
要不然就想第一个一样，没完全释放！