）执行构造函数函数体
?
注：你可能会疑惑，如下代码不是将Base间接基类创建了3次吗？其实不是这样的，编译器是这样处理的，当最远的派生类Derived创建了基类Base之后，其直接基类创建Base类的语句将会被忽略掉。
?
复制代码
?1 class Base
?2 {
?3 public:
?4 ? ? Base(int b) : m_b(b)
?5 ? ? {
?6 ? ? }
?7 private:
?8 ? ? int m_b;
?9 };
10?
11 class Base1 : virtual public Base
12 {
13 public:
14 ? ? Base1(int b, int b1) : Base(b), m_b1(b1)
15 ? ? {
16 ? ? }
17 private:
18 ? ? int m_b1;
19 };
20?
21 class Base2 : virtual public Base
22 {
23 public:
24 ? ? Base2(int b, int b2) : Base(b), m_b2(b2)
25 ? ? {
26 ? ? }
27 private:
28 ? ? int m_b2;
29 };
30 //虚继承，避免二义性
31 class Derived : public Base1, public Base2
32 {
33 public:
34 ? ? Derived(int b, int b1, int b2, int d) : Base(b), Base1(b, b1), Base2(b, b2), m_d(d)
35 ? ? { //注意冒号语法后面的顺序无所谓，创造基类是按照上面的继承声明顺序来进行的...
36 ? ? }
37 private:
38 ? ? int m_d;
39 };
复制代码
五、关于虚析构
?
虚析构一般伴随着多态而产生，多态主要方式就是用基类的指针或引用指向或引用派生类，而形成多态。
?
但是这样就会存在一个问题，当我们析构的时候，由于是基类的指针，就会调用的是基类的构造函数，从而造成派生内存溢出。为了解决这个问题，引入了虚析构的概念。将基类的构造函数声明为虚，从而使其在调用析构函数的时候能够准确的调用派生类的析构函数。
?
如下代码必须用到虚析构才能准确的析构派生类，并释放其占有内存。
?
复制代码
?1 class Base
?2 {
?3 public:
?4 ? ? Base(int b) : m_b(b)
?5 ? ? {
?6 ? ? }
?7 ? ? //虚析构，使基类指针能准确的释放所指向的派生类里面的内容
?8 ? ? virtual ~Base()
?9 ? ? {
10 ? ? }
11 private:
12 ? ? int m_b;
13 };
14?
15 class Derived : public Base
16 {
17 public:
18 ? ? Derived(int b, char *pStr) : Base(b)
19 ? ? {?
20 ? ? ? ? m_pStr = new char[strlen(pStr)+1];
21 ? ? ? ? strcpy(m_pStr,pStr);
22 ? ? }
23 ? ? ~Derived()
24 ? ? {
25 ? ? ? ? delete m_pStr;
26 ? ? ? ? m_pStr = NULL;
27 ? ? }
28 private:
29 ? ? char *m_pStr;
30 };
31?
32 int main(void)
33 {
34 ? ? char *pStr = "abcdefg";
35 ? ? Base *b = new Derived(1,pStr);
36 ? ? delete b;
37?
38 ? ? return 0;
39 }