关于C++继承体系中类的构造与析构的顺序【转贴】

关于C++继承体系中类的构造与析构的顺序
1.构造函数
先看下面的类定义
class B1 class B2
{ {
public: public:
int i; int i;
B1() { i = 0; } B2() { i = 0; }
virtual void f() {} virtual void f() {}
} ; } ;

class M1 class M2
{ {
public: public:
int i; int i;
M1() { i = 0; } M2() { i = 0; }
virtual void mf() {} virtual void mf() {}
} ; };

class C : public B1, public B2
{
public:
virtual void f() {}
M1 m1;
M2 m2;
};

（1）编译器会不会为C生成默认构造（default ctor）
编译器只在需要时才会为一个类生成def ctor。“需要时”指：
a.一个类有虚函数
b.一个类有虚基类
c.一个类的基类有def ctor
d.一个类的成员类有def ctor
在这里，class C符合c,d两个条件，编译器会为它生成def ctor.

（2）默认构造的内容
编译器生成的def ctor是这样的
C::C()
{
B1::B1()
B2::B2()
设定虚表指针指向C的虚表
m1::M1()
m2::M2()
}
a.按声明顺序构造基类
b.设定虚表指针
c.按声明顺序构造成员类

（3）对自定义构造函数的改造
对于B1，B2，M1，M2，已有构造函数，但编译器会对其改造，加入一些代码，完成必要的初始化工作。改造后的ctor如下：（以B1为例）
B1::B1()
{
设定虚表指针指向B1的虚表
i = 0;
}
a.设定虚表指针
b.如果用户写有代码（如i=0）,则执行这些代码

（4）综合（2），（3），构造函数完整代码如下
T::T()
{
按声明顺序构造基类
设定虚表指针
按声明顺序构造成员类
如果用户写有代码,则执行这些代码
}
在用户代码执行前，基类与成员类已构造完毕，虚指针已设定。

所以C的构造顺序是：B1-〉B2-〉虚指针设定-〉m1-〉m2->C自己的代码（如果有的话）
由（3）可知，每个类的ctor中，都会暂时将虚指针指向自己的虚表。调用B1::B1时，虚指针指向B1的虚表，然后在C::C中，虚指针被重新设定为C的虚表。
在继承体系中，构造是由上而下的，B1或B2构造时，C还未构造。C构造时，B1和B2已构造完成。

所以在继承体系中，一个类的构造函数执行时，该类的所有基类已构造完毕，虚指针已设定，所有成员类也已构造完毕。但该类的所有子类均未构造完成。

2.析构函数
（1）编译器会不会为C生成析构函数（dtor）
编译器只在需要时才会为一个类生成dtor。“需要时”指：
a.类的基类有析构
b.类的成员类有析构
与构造不同，少了两点，因为在一个类析构时，这是一个破坏操作（destory），既然类以已经没用了，何必再把虚指针设一下呢。

（2）析构的内容
编译器生成的析构是这样的
C::~C()
{
m2::M2()
m1::M1()
B2::B2()
B1::B1()
}
a.按声明顺序相反的顺序析构成员类
b.按声明顺序相反的顺序析构基类
这里的相反顺序是C++标准规定的要求，不同编译器都应做到，否则不符合标准（实际上编译器或多或少都有不符标准的地方，当然不是指这里所说的顺序问题）

（3）完整的析构的调用顺序
对于已有析构函数的类，编译器会对其改造，加入一些代码，完成必要的工作。改造后的dtor如下：
T::~T()
{
设定虚表指针指向T的虚表
执行用户代码
按声明顺序相反的顺序析构成员类
按声明顺序相反的顺序析构基类
}
这是完整的析构的调用顺序
在用户代码执行前，虚指针已重新设定，以便用户代码能正确执行。然后再析构成员类和基类。

所以，如果上面例子中的五个类都有析构函数的话，调用顺序是：
虚指针设定-〉C自己的代码->m2-〉m1-〉B2-〉B1
每个类的dtor中，都会暂时将虚指针指向自己的虚表。调用C::~C时，虚指针指向C的虚表，然后在B1::~B1中，虚指针被重新设定为B1的虚表。

可见，在继承体系中，析构是由下而上的，B1或B2析构时，C已被析构。C析构时，B1和B2还未被析构。
所以在继承体系中，一个类的析构函数执行时，该类的所有基类还未被析构，所有成员类也未被析构。但该类的所有子类均已析构完成。

3.虚函数
在构造或析构中调用虚函数，会怎样.如：
B1：：B1（）
{
f();
}
调用的是B1：：f（）还是C：：f（）
答案是B1::f()
每个类的ctor中，都会暂时将虚指针指向自己的虚表。调用B1::B1时，虚指针指向B1的虚表
所以是B1：：f（）
如果在C的构造函数中调用f（），那就调用C：：f（）