C++关于继承与派生的简单小程序

规则是没有问题的。我给你描述一下吧

首先，调用派生类的构造函数，这个时候派生类没有被创建

调用构造该派生类的基类

调用派生类的成员的构造函数，顺序按照派生类中声明顺序执行

最后执行派生类构造函数构造体内的内容。

所以在你的这个例子里。

先是基类2,1,3

然后是成员Member

然后再执行派生类构造函数里面的内容，也就是cout<<"Dervied"<<endl

/**************************************************/

1，

代码风格不好，阅读性不好，扩展性不好

2，

理解这段代码，需要掌握

类的继承派生，虚基类，构造及析构

(没有函数重载，没有构造函数重载，有更烦)

3，

我把代码重新排版一下，便于阅读

我代码很整齐的，该死的百度，乱排版...

介绍一下个人方法：

在阅读类的说明时候，自己在草稿上写下：

A(int a):x(a)

A(a)

A Aobj(c)

B(int a,int b,int c):A(a),y(c),Aobj(c)

A(0)

virtual A(a)

A Aobj(c)

B(a,b,c)

C(int a,int b,int c):B(a,b,c),A(0)

A(c)

virtual A(a)

virtual A(0)

A Aobj(c)

B(a,b,c)

C(a,b,c)

D(int a,int b,int c):C(a,b,c),A(c)

4，

上面有四段，每段是一个类

拿最后一段来说明

D直接继承了C，A；C直接继承了B，A；B直接继承了A

所以D继承了ABC，而且父类树要在草稿上画好

用类D来说明对象时，分配存储空间时候

会分析派生继承树，从最上层开始构造

a，b，c是值传递

先构造A(c) D直接构造了虚基类

再构造A(a) 这是有virtual虚基类说明，所以不构造了

再构造A(0) 这是有virtual虚基类说明，所以不构造了

再构造A Aobj(c) 注意Aobj是对象，要构造，不是虚基类

再构造B(a,b,c)

再构造C(a,b,c)

最后构造D(int a,int b,int c)

析构的时候顺序就反过来

记住虚基类只构造一次，而且是D直接给值

如果D中没有A(c)，也不会用BC中的初始化A来构造

而会直接用A中的缺省构造函数了构造

你的A种没有缺省构造函数了构造，所以D中如果没有A(c)会错

5,

(构造析构没说明系统会自动给默认的)

那么派生之后D的成员有哪些呢

d.Aobj.f

d.Aobj.x private B private A 访问

d.Aobj.A

d.Aobj.~A

d.display

d.f

d.x private A 访问

d.y private B 访问

A ~A

B ~B

C ~C

D ~D

ABC的成员自己写吧，草稿纸用去不少啊

/**************************************************/

好了，下面分析main

D d(7,8,9)

说明对象d，分配给存储空间

A(9)

virtual A(a)

virtual A(0)

A Aobj(9)

B(7,8,9)

C(7,8,9)

D(7,8,9)

做什么事情很简单了吧,就是构造函数{}中的事情：

A(9) cout<<"A constructor..."<<9<<endl

A Aobj(9) cout<<"A constructor..."<<9<<endl

B(7,8,9) cout<<"B constructor..."<<endl

C(7,8,9) cout<<"C constructor..."<<endl

D(7,8,9) cout<<"C constructor..."<<endl

值的传递也会在构造的时候进行

你要在草稿上写下这时候d的数据成员

d.x=9

d.y=9

d.Aobj.x=9

其他是函数成员

d.f()

A和B中都有f()从树子到树父去找到调用

(分析的时候注意f()是谁在改变谁的)

找到B的f()函数，调用A::f()Aobj.f()return ++y

A::f()之后输出9，d.x=10

Aobj.f() 之后输出9，d.Aobj.x=10

return ++y之后d.y=10

d.display()

只有一个display()

调用cout<<A::f()<<"\t"<<Aobj.f()<<"\t"<<f()<<endl

从后往前：

f() 调用B的f()函数A::f()Aobj.f()return ++y

A::f()输出10，d.x=11

Aobj.f() 输出10，d.Aobj.x=11

return ++yd.y=11

准备输出d.y值11

Aobj.f() Aobj是A类，调用A的f()

输出11，d.Aobj.x=12

准备输出d.Aobj.x值12

A::f()

输出11，d.x=12

准备输出d.x值12

然后输出12 12 11

/**************************************************/

总结

构造从树父到树子，其余从树子到树父

虚基类构造只一次

/**************************************************/

#include<iostream>

using namespace std

class A

{

private:

int x

public:

A(int a):x(a)

{

cout<<"A constructor..."<<x<<endl

}

int f()

{

cout<<x<<endl

return ++x

}

~A()

{

cout<<"destructor A..."<<endl

}

}

class B:public virtual A

{

private:

int y

A Aobj

public:

B(int a,int b,int c):A(a),y(c),Aobj(c)

{

cout<<"B constructor..."<<y<<endl

}

int f()

{

A::f()

Aobj.f()

return ++y

}

void display()

{

cout<<A::f()<<"\t"<<Aobj.f()<<"\t"<<f()<<endl

}

~B()

{

cout<<"destructor B..."<<endl

}

}

class C:public B

{

public:

C(int a,int b,int c):B(a,b,c),A(0)

{

cout<<"C constructor..."<<endl

}

}

class D:public C,public virtual A

{

public:

D(int a,int b,int c):C(a,b,c),A(c)

{

cout<<"D constructor..."<<endl

}

~D()

{

cout<<"destructor D...."<<endl

}

}

int main()

{

D d(7,8,9)

d.f()

d.display()

return 0

}

---