C++_Lecture

Size: px

Start display at page:

Download "C++_Lecture"

笃单
5 years ago
Views:

1 C++ 程序设计张岳新编著苏州大学出版社 1

2 第十一章继承和派生类 2

3 继承性是面向对象程序设计中最重要的机制这种机制提供了无限重复利用程序资源的一种途径通过 C++ 语言中的继承机制, 可以扩充和完善旧的程序设计以适应新的需求这样不仅可以节省程序开发的时间和资源, 并且为未来程序增添了新的资源 3

4 class Student { int num; char name[30]; char se; public: void display( ) // 对成员函数 display 的定义 {cout<<"num: "<<num<<endl; cout<<"name: "<<name<<endl; cout<<"se: "<<se<<endl; } 4

5 class Studend1 { int num; // 此行原来己有 char name[20]; // 此行原来己有 char se; // 此行原来己有 int age; char addr[20]; public: void display( ) ; // 此行原来己有 {cout<<"num: "<<num<<endl; // 此行原来己有 cout<<"name: "<<name<<endl;// 此行原来己有 cout<<"se: "<<se<<endl; // 此行原来己有 cout<<"age: "<<age<<endl; cout<<"address: "<<addr<<endl;} 5

6 利用原来定义的类 Student 作为基础, 再加上新的内容即可, 以减少重复的工作量 C++ 提供的继承机制就是为了解决这个问题在 C++ 中所谓继承就是在一个已存在的类的基础上建立一个新的类已存在的类称为基类 (base class) 或父类 (father class) 新建立的类称为派生类 (derived class) 或子类 (son class) 6

7 class Student1: public Student// 声明基类是 Student {private: int age; // 新增加的数据成员 string addr; // 新增加的数据成员 public: void display_1( ) // 新增加的成员函数 { cout<<"age: "<<age<<endl; cout<<"address: "<<addr<<endl; } 7

8 类 A 派生类 B: 类 A 为基类, 类 B 为派生类 A B 新增加的成员数据和成员函数 8

9 在 C++ 语言中, 一个派生类可以从一个基类派生, 也可以从多个基类派生从一个基类派生的继承称为单继承 ; 从多个基类派生的继承称为多继承 9

10 通过继承机制, 可以利用已有的数据类型来定义新的数据类型所定义的新的数据类型不仅拥有新定义的成员, 而且还同时拥有旧的成员我们称已存在的用来派生新类的类为基类, 又称为父类由已存在的类派生出的新类称为派生类, 又称为子类 10

11 在建立派生类的过程中, 基类不会做任何改变, 派生类则除了继承基类的所有可引用的成员变量和成员函数外, 还可另外定义本身的成员变量和处理这些变量的函数, 由于派生类可继承基类的成员变量和成员函数, 因此在基类中定义好的数据和函数等的程序代码可重复使用, 这样可以提高程序的可靠性 11

12 当从已有的类中派生出新的类时, 可以对派生类做以下几种变化 : 1 可以继承基类的成员数据或成员函数 2 可以增加新的成员变量 3 可以增加新的成员函数 4 可以重新定义已有的成员函数 5 可以改变现有的成员属性在 C++ 中有二种继承 : 单一继承和多重继承当一个派生类仅由一个基类派生时, 称为单一继承 ; 而当一个派生类由二个或更多个基类所派生时, 称为多重继承 12

13 类 A 派生类 B: 类 A 为基类, 类 B 为派生类 A B class B:public A{... class B:protected A{... class B:private A{... class B: A {... A 为私有派生但派生并不是简单的扩充, 有可能改变基类的性质有三种派生方式 : 公有派生保护派生私有派生默认的是私有派生 13

14 从一个基类派生一个类的一般格式为 : class ClassName:<Access>BaseClassName { 派生类名继承方式 private:...; // 私有成员说明 public:...; // 公有成员说明 protected:...; // 保护成员说明 } public: 表示公有基类 private: 表示私有基类 ( 默认 ) protected: 表示保护基类基类名派生类中新增加的成员 14

15 公有派生公有派生, 派生类中保持基类的成员特性 class ClassName: public BaseClassName 公有派生时, 基类中所有成员在派生类中保持各个成员的访问权限基类成员属性派生类中派生类外公有可以引用可以引用保护可以引用不可引用私有不可引用不可引用基类 :public: 在派生类和类外可以使用 protected: 在派生类中使用 private: 不能在派生类中使用 15

16 A ( 私有 ) y( 保护 ) z( 公有 ) A( ) Get() Gety() ShowA() public 在类 B 新增加的成员中不能直接调用 y 在类 B 中可以调用 z 在整个文件中可以调用 B ( 私私有 ) y( 保护 ) z( 公有 ) A( ) Get() Gety() ShowA() m( 私有 ) n( 私有 ) B() Show() Sum() 对类 B 的对象初始化即是对,y,z,m,n 等全部成员的初始化 16

17 class A { int ; protected: int y; public: int z; A(int a,int b,int c){=a;y=b;z=c;}// 基类初始化 int Get(){return ;} // 返回 int Gety(){return y;} // 返回 y void ShowA(){cout<< "="<<<<'\t'<<"y="<<y<<'\t'<<"z="<<z<<'\n';} 公有派生 class B:public A{ int m,n; 对基类初始化 public: B(int a,int b,int c,int d,int e):a(a,b,c){m=d;n=e;} void Show(){cout<< m="<<m<<'\t'<< n="<<n<<'\n'; cout<<"="<<get()<<'\t'<<"y="<<y<<'\t'<<"z="<<z<<'\n'; } int Sum(){return ( Get()+y+z+m+n);} void main(void) { B b1(1,2,3,4,5); b1.showa(); 因为 y 是基类保护, 所以在派生类中可以直接引用而在类外不可直接引用因为是基类私有, 所以在派生类和类外中不能直接引用 b1.show(); cout<< "Sum="<<b1.Sum()<<'\n';cout<<"="<<b1.Get()<<'\t'; cout << "y=" <<b1.gety()<<'\t'; cout << "z="<<b1.z<<'\n';} 因为 z 是基类公有, 所以在派生类中和类外均可直接引用 17

18 私有派生私有派生, 派生类中基类公有和保护成员成为私有私有派生时, 基类中公有成员和保护成员在派生类中均变为私有的, class ClassName: private BaseClassName 在派生类中仍可直接使用这些成员, 基类中的私有成员, 在派生类中不可直接使用基类成员属性派生类派生类外公有可以引用不可引用保护可以引用不可引用私有不可引用不可引用基类 :public: ( 变为私有 ) 在派生类中使用, 类外不可使用 protected: ( 变为私有 ) 在派生类中使用, 类外不可使用 private: 不能在派生类中和类外使用 18

19 A ( 私有 ) y( 保护 ) z( 公有 ) A( ) Get() Gety() ShowA() 在类 B 新增加的成员中不能直接调用 y 在类 B 中可以调用 z 在类 B 中可以调用 B private ( 私有 ) y( 私有 ) z( 私有 ) A( ) Get() Gety() ShowA() m( 私有 ) n( 私有 ) B() Show() Sum() 均为私有类 B 外不能引用对类 B 的对象初始化即是对,y,z,m,n 等全部成员的初始化 19

20 class A { int ; protected: int y; public: int z; A(int a,int b,int c){=a;y=b;z=c;}// 基类初始化 int Get(){return ;} // 返回 int Gety(){return y;} // 返回 y void ShowA(){cout<< "="<<<<'\t'<<"y="<<y<<'\t'<<"z="<<z<<'\n';} 私有派生 class B:private A{ int m,n; 对基类初始化 public: B(int a,int b,int c,int d,int e):a(a,b,c){m=d;n=e;} void Show(){cout<< m="<<m<<'\t'<< n="<<n<<'\n'; cout<<"="<<get()<<'\t'<<"y="<<y<<'\t'<<"z="<<z<<'\n'; } int Sum(){return ( Get()+y+z+m+n);} void main(void) { B b1(1,2,3,4,5); b1.showa(); 因为是基类私有, 所以在派生类和类外中不能直接引用 A a1(1,2,3); a1.showa(); y 是基类保护, 所以在派生类中可以直接引用而在类外不可直接引用 z 是基类公有, 私有派生变为私有, 所以在派生类中可直接引用, 而在类外不可这些函数都是基类公有, 在类外不可使用 b1.show(); cout<< "Sum="<<b1.Sum()<<'\n';cout<<"="<<b1.Get()<<'\t'; cout << "y=" <<b1.gety()<<'\t'; cout << "z="<<b1.z<<'\n';} 20

21 保护派生保护派生, 派生类中基类公有和保护成员降级使用 class ClassName: protected BaseClassName 保护派生时, 基类中公有成员和保护成员在派生类中均变为保护的和私有的 ( 错吧? 应该改为保护的 ), 在派生类中仍可直接使用这些成员, 基类中的私有成员, 在派生类中不可直接使用基类成员属性派生类派生类外公有可以引用不可引用保护可以引用不可引用私有不可引用不可引用基类 :public: ( 变为保护 ) 在派生类中使用, 类外不可使用 protected: ( 变为私有 ( 应改为保护 ) ) 在派生类中使用, 类外不可使用 private: 不能在派生类中和类外使用 21

22 A ( 私有 ) y( 保护 ) z( 公有 ) A( ) Get() Gety() ShowA() 在类 B 新增加的成员中不能直接调用 y 在类 B 中可以调用 z 在类 B 中可以调用 B protected ( 私私有 ) y( 私有 ) z( 保护 ) A( ) Get() Gety() ShowA() m( 私有 ) n( 私有 ) B() Show() Sum() 均为保护类 B 外不能引用对类 B 的对象初始化即是对,y,z,m,n 等全部成员的初始化 22

23 protected 成员是一种具有血缘关系内外有别的成员它对派生类的对象而言, 是公开成员, 可以访问, 对血缘外部而言, 与私有成员一样被隐蔽 23

24 抽象类与保护的成员函数当定义了一个类, 这个类只能用作基类来派生出新的类, 而不能用这种类来定义对象时, 称这种类为抽象类当对某些特殊的对象要进行很好地封装时, 需要定义抽象类将类的构造函数或析构函数的访问权限定义为保护的时, 这种类为抽象类 24

25 当把类中的构造函数或析构函数说明为私有的时, 所定义的类通常是没有任何实用意义的, 一般情况下, 不能用它来产生对象, 也不能用它来产生派生类 25

26 A ( 私有 ) y( 私有 ) A( )( 保护 ) ShowA()( 公有 ) B public 在类 B 中不能定义 A 的对象在任何时候都不能定义 A 的对象 ( 私私有 ) y( 私私有 ) A( )( 保护 ) ShowA() m( 私有 ) B() Show() 但可以在初始化类 B 的对象时初始化原类 A 中的成员, 因为 A() 在类 B 中是可以被调用的 26

27 class A { int, y; protected: A(int a,int b){=a;y=b;}// 基类初始化 public: void ShowA(){cout<< "="<<<<'\t'<<"y="<<y<<'\n';} class B: public A{ int m; A a1; // 在派生类中也不可以定义 A 的对象, 实际上还是类外调用 public: a1(4,5) B(int a,int b,int c):a(a,b)// 可以在派生类中调用 A 的构造函数 {m=c;} void Show(){ cout<< m="<<m<<'\n'; ShowA(); } void main(void) { B b1(1,2,3); // 可以定义派生类对象 b1.show(); A aa; // 不可定义 A 的对象 } 27

28 多重继承可以用多个基类来派生一个类 D A B 多重继承是单一继承的扩展 C 派生类中新定义的成员 28

29 格式为 : 继承方式 class 类名 :<Access> 类名 1,..., <Access> 类名 n { private:... ; // 私有成员说明 ; public:... ; // 公有成员说明 ; protected:... ; // 保护的成员说明 ; class D: public A, protected B, private C {...// 派生类中新增加成员 29

30 class A{ int 1,y1; public: A(int a,int b) { 1=a; y1=b; } void ShowA(void){ cout<<"a.="<<1<<'\t'<<"a.y="<<y1<<endl; } class B{int 2,y2; public: B(int a,int b) {2=a; y2=b; } void ShowB(void){ cout<<"b.="<<2<<'\t'<<"b.y="<<y2<<endl; } 公有派生私有派生 class C:public A,private B{ int,y; public: C(int a,int b,int c,int d,int e,int f):a(a,b),b(c,d) {=e; y=f; } void ShowC(void){cout<<"C.="<<<<'\t'<<"C.y="<<y<<endl; ShowA();ShowB(); } void main(void) { C c(1,2,3,4,5,6); c.showc(); } c.showa (); c.showb (); 仍为公有成为私有非法, 私有类外不可调用 B b1(10,20); b1.showb(); 30

31 初始化基类成员构造函数不能被继承, 派生类的构造函数必须调用基类的构造函数来初始化基类成员基类子对象派生类构造函数的调用顺序如下 : 基类的构造函数子对象类的构造函数派生类的构造函数 31

32 class B:public A{ int y; A a1; public: 基类的构造函数子对象类的构造函数派生类的构造函数 B(int a, int b):a(a),a1(3){y=b;}... 当撤销派生类对象时, 析构函数的调用正好相反 32

33 class Base1 { int ; public: Base1(int a){ =a;cout<<" 调用基类 1 的构造函数!\n"; } ~Base1( ){ cout<<" 调用基类 1 的析构函数!\n"; } class Base2 { int y; public: Base2(int a){ y=a;cout<<" 调用基类 2 的构造函数!\n"; } ~Base2( ){ cout<<" 调用基类 2 的析构函数!\n"; } 先说明基类 2 class Derived:public Base2, public Base1{ int z; public: Derived(int a,int b):base1(a),base2(20) {z=b; cout<<" 调用派生类的构造函数!\n";} ~Derived( ){cout<<" 调用派生类的析构函数!\n";} void main(void) { Derived c(100,200); 33 } 调用基类 2 的构造函数调用基类 1 的构造函数调用派生类的构造函数调用派生类的析构函数调用基类 1 的析构函数调用基类 2 的析构函数

34 class Derived:public Base2, public Base1{ int z; 基类子对象 Base1 b1,b2; public: 基类成员构造基类子对象构造 Derived(int a,int b):base1(a),base2(20), b1(200),b2(a+b) {z=b; cout<<" 调用派生类的构造函数!\n";} ~Derived( ){cout<<" 调用派生类的析构函数!\n";} void main(void) { Derived c(100,200); } 基类成员构造用基类名, 基类子对象构造用对象名 34

35 class Base1 { int ; public: Base1(int a){ =a;cout<<" 调用基类 1 的构造函数!\n"; } ~Base1( ){ cout<<" 调用基类 1 的析构函数!\n"; } class Base2 { int y; public: Base2(int a){ y=a;cout<<" 调用基类 2 的构造函数!\n"; } ~Base2( ){ cout<<" 调用基类 2 的析构函数!\n"; } class Derived:public Base2, public Base1{ int z; Base1 b1,b2; public: Derived(int a,int b):base1(a),base2(20), b1(200),b2(a+b) {z=b; cout<<" 调用派生类的构造函数!\n";} ~Derived( ){cout<<" 调用派生类的析构函数!\n";} void main(void) { Derived c(100,200); 35 }

36 调用基类 2 的构造函数调用基类 1 的构造函数调用基类 1 的构造函数调用基类 1 的构造函数调用派生类的构造函数调用派生类的析构函数调用基类 1 的析构函数调用基类 1 的析构函数调用基类 1 的析构函数调用基类 2 的析构函数说明基类 1 的对象 b1,b2 36

37 class Base1 { int ; public: Base1(int a); ~Base1( ); class Base2 { int y; public: Base2(int a); ~Base2( ); Base1 Base2 Base1() ~Base1() y Base2() ~Base2() class Derived:public Base2, public Base1{ int z; Base1 b1,b2; public: Derived(int a,int b); ~Derived( ); Derived b1 b2 Base1() ~Base1() y Base2() ~Base2() Base1() ~Base1() Base1() ~Base1() z Derived() ~Derived 37

38 冲突派生类对象 A B A() B() public D A() B() D v; v.=5; 产生了冲突 C C() C() d A::v.=5; 用类作用符限定 D() 38

39 class A{ public: int ; void Show(){cout <<"="<<<<'\n';} 这时, 可以利用类作用 A(int a=0){=a;} 域符 :: 来指明数据或函数的来源 class B{ public: int ; 如 :A::=a; void Show(){cout <<"="<<<<'\n';} c1.b::show(); B(int a=0){=a;} class C:public A,public B{ int y; public: void Set(int a){ =a;} //c1 对象中有两个成员 void Sety(int b){y=b;} int Gety() {return y;} void main(void) 39 { C c1; c1.show(); //c1 对象中有两个 Show() 函数 }

40 支配规则基类成员 A public D A() A() 5 派生类新增成员 D() D v; v.=5; 当派生类中新增加的数据或函数与基类中原有的同名时, 若不加限制, 则优先调用派生类中的成员 40

41 class A{ public: int ; void Show(){cout <<"="<<<<'\n';} class B{ public: int y; void Show(){cout <<"y="<<y<<'\n';} class C:public A,public B{ public: int y; // 类 B 和类 C 均有 y 的成员 void main(void) { C c1; c1.=100; c1.y=200; // 给派生类中的 y 赋值 c1.b::y=300; // 给基类 B 中的 y 赋值 c1.a::show(); c1.b::show(); // 用作用域运算符限定调用的函数 cout <<"y="<<c1.y<<'\n'; // 输出派生类中的 y 值 cout <<"y="<<c1.b::y<<'\n'; // 输出基类 B 中的 y 值 } 当派生类中新增加的数据或函数与基类中原有的同名时, 若不加限制, 则优先调用派生类中的成员 41

42 class A{ public: int ; A(int a=0) { =a;} class B{ public: int y; B(int a=0) { y=a;} class C:public A{ int z; B b1; A a1; public: C(int a,int b,int m):a(a),b1(b),a1(a+b){ z=m; } void Show( ){ cout<<"="<<<<'\t'; cout<<"y="<<b1.y<<'\t'; cout<<"="<<z<<'\n'; cout<<"a1.="<<a1.<<endl; } void main(void) { C c1(100,200,500); c1.show();} 从基类 A 中继承新说明类 A 对象中的从基类 A 中继承在类 C 中新说明在类 C 中新说明在类 C 中新说明在类 C 中新说明 z Show() a1. b1.y C 的对象所占空间 42

43 基类与对象成员任一基类在派生类中只能继承一次, 否则, 会造成成员名的冲突若在派生类中, 确实要有二个以上基类的成员, 则可用基类的二个对象作为派生类的成员把一个类作为派生类的基类或把一个类的对象作为一个类的成员, 在使用上是有区别的 : 在派生类中可直接使用基类的成员 ( 访问权限允许的话 ), 但要使用对象成员的成员时, 必须在对象名后加上成员运算符. 和成员名 43

44 在平面上作两个点, 连一直线, 求直线的长度和直线中点的坐标基类为 Dot, 有两个公有数据成员, 即平面上的坐标 (,y), 同时有构造函数及打印函数派生类为 Line, 有两个基类 Dot 对象, 分别存放两点的坐标, 同时, 从基类继承了一个 Dot 数据, 存放直线中点的坐标 44

45 y Dot(,y)( 构造 ) Dot(&dot)( 拷贝 ) Show() Dot 的对象空间 Line 对象空间 ( 中点 ) y( 中点 ) Dot(,y) Dot(&dot) Show() y d1 Dot(.y) Dot(&dot) Show() y d2 Dot(,y) Dot(&dot) Show() Line(dot1,dot2) Showl() 从基类继承基类对象 45

46 class Dot{ public: float,y; 用坐标初始化 Dot 对象 Dot(float a=0,float b=0){ =a; y=b;} void Show(void){cout<<"="<<<<'\t'<<"y="<<y<<endl;} class Line:public Dot{ Dot d1,d2; 打印坐标在 Line 中新说明的成员 public: Line(Dot dot1,dot dot2):d1(dot1),d2(dot2) { =(d1.+d2.)/2; y=(d1.+d2.y)/2;} 对成员初始化 void Showl(void){ cout<<"dot1: "; d1.show(); cout<<"dot2: "; d2.show(); cout<<"length="<<sqrt((d1.-d2.)*(d1.-d2.)+(d1.y-d2.y)*(d1.y-d2.y))<<endl; cout<<"center: "<<"="<<<<'\t'<<"y="<<y<<endl; } void main(void) { float a,b; cout<<"input Dot1: \n"; cin>>a>>b; Dot dot1(a,b);// 调用 Dot 的构造函数 cout<<"input Dot2: \n"; cin>>a>>b; Dot dot2(a,b); Line line(dot1,dot2); line.showl();},y 是继承基类的成员 46

47 赋值兼容规则相互之间能否赋值? 基类对象 Base b; 派生类对象 Derive d; 可以将派生类对象的值赋给基类对象反之不行 b = d; 只是将从基类继承来的成员赋值 47

48 y Dot(,y) Dot(&dot) Show() Dot 的对象空间 Dot dot; Line line; dot=line; line=dot; Line 的对象空间非法 d1 d2 y Dot(,y) Dot(&dot) Show() y Dot(.y) Dot(&dot) Show() y Dot(,y) Dot(&dot) Show() Line() Showl() 从基类继承基类对象 48

49 可以将一个派生类对象的地址赋给基类的指针变量 Base *basep; basep=&b; 基类指针派生类对象 basep 只能引用从基类继承来 basep = &d 的成员基类对象基类对象 basep Base b; basep 派生类对象 Derive d; 49

50 派生类对象可以初始化基类的引用 Derive d; Base basei=&d; 派生类对象 basei 只能引用从基类继承来基类引用的成员基类对象别名 basei 派生类对象 Derive d; Base b; 50

51 class A{ public: int ; A(int a=0) { =a;} class B{ public: int y; B(int a=0) { y=a;} class C:public A,public B{ int z; public: C(int a,int b,int m): A(a), B(b) { z=m; } void Show( ){ cout<<"="<<<<'\t'; cout<<"y="<<y<< \t ; cout<<"z="<<z<<'\n'; } void main(void) { A a1(100); B b1(200); C c1(10,20,50); } a1.=100 b1.y=200 =10 y=20 z=50 a1.=10 b1.y=20 cout<<"a1.="<<a1.<<endl; cout<<"b1.y="<<b1.y<<endl; c1.show(); a1=c1; b1=c1;// 派生类对象向基类对象赋值 cout<<"a1.="<<a1.<<endl; cout<<"b1.y="<<b1.y<<endl; A *p; p=&c1; // 基类指针指向派生类对象 p->show(); a1 b1 100 A( ) 200 y B( ) c1 A( ) y B( ) z C( ) Show( ) 错误 51!

52 虚基类类 B 是类 A 的派生类类 C 是类 A 的派生类类 A 拷贝 A() y B 类类 D 是类 B 和类 C 的派生类 B() 这样, 类 D 中就有两份类 A 的拷贝 A() A() A() y z A 类 B() C() B 类 C 类类 A 拷贝 A() z C() d D() D 类 52 C 类

53 这种同一个公共的基类在派生类中产生多个拷贝, 不仅多占用了存储空间, 而且可能会造成多个拷贝中的数据不一致和模糊的引用类 A 拷贝类 A 拷贝 A() y B() A() z B 类 C 类 C() D d; d.=10; // 模糊引用 d D() D 类 53

54 class A{ public: int ; A(int a=0) { =a;} class B:public A{ public: int y; B(int a=0,int b=0):a(a) { y=b;} class C:public A{ public: int z; C(int a,int c):a(a){ z=c; } class D:public B,public C{ public: int d; D(int a1,int b,int c,int d,int a2):b(a1,b),c(a2,c) { d=d;} 模糊引用, 错误! void main(void) { D d1(10,20,30,40,50); cout<<d1.<<endl; } A() y B() A() z C() d D() D 类 a1=10 b=20 a2=50 c=30 d=40 54

55 在多重派生的过程中, 若使公共基类在派生类中只有一个拷贝, 则可将这种基类说明为虚基类在派生类的定义中, 只要在基类的类名前加上关键字 virtual, 就可以将基类说明为虚基类 class B:public virtual A{ public: int y; B(int a=0, int b=0 ):A(b) { y=a;} 55

56 一份拷贝, 在 D( ) 的构造函数中直接调用 A() A() A() A() A() 由虚基类派生出的对象初始 A 类 y z y 化时, 直接调用虚基类的构 B() B 类 C() C 类 B() z C() d D() 造函数因此, 若将一个类定义为虚基类, 则一定有正确的构造函数可供所有派生类调用 D 类 56

57 class A{ void main(void) public: int ; { D d1(10,20,30,40,50); A(int a=0) { =a;} cout<<d1.<<endl; d1.=400; class B:public virtual A{ cout<<d1.<<endl; public: int y; cout<<d1.y<<endl; B(int a=0,int b=0): A(a) {y=b;} } class C:public virtual A{ 50 0 public: int z; C(int a=0,int c=0):a(a){z=c; } class D:public B,public C{ 直接在派生类中调用虚基类的构造函数 public: int d; D(int a1,int b,int c,int d,int a2):b(a1,b),c(a2,c), A(a2) { d=d;} 没有对虚基类构造函数的调用, 用缺省的构造函数 57

58 再次强调, 用虚基类进行多重派生时, 若虚基类没有缺省的构造函数, 则在每一个派生类的构造函数中都必须有对虚基类构造函数的调用 ( 且首先调用 ) 58

OOP with Java 通知 Project 4: 4 月 18 日晚 9 点关于抄袭没有分数

OOP with Java Yuanbin Wu cs@ecnu OOP with Java 通知 Project 4: 4 月 18 日晚 9 点关于抄袭没有分数复习类的复用组合 (composition): has-a 关系 class MyType { public int i; public double d; public char c; public void set(double