面向对象的程序设计 : 抽象 继承和多态 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

Transcription

1 程序设计与算法语言 继承与派生 C/C++ Programming and Algorithms Inheritance and Derivation Dongke Sun ( 孙东科 ) dksun@seu.edu.cn 东南大学机械工程学院 School of Mechanical Engineering Southeast University April 12, 2018

2 面向对象的程序设计 : 抽象 继承和多态 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

3 提纲 1 访问冲突 2 支配规则 3 虚基类与构造函数 4 赋值兼容及其限制 5 总结与思考 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

4 提纲 访问冲突 1 访问冲突 2 支配规则 3 虚基类与构造函数 4 赋值兼容及其限制 5 总结与思考 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

5 访问冲突 访问冲突 在类的多重继承情况下, 1 派生类对其自身及基类成员的访问应该是唯一的和无争议的 ; 2 然而, 派生类有时会面临对基类成员的访问出现冲突的情况 这种发生访问冲突的现象就是多继承中的访问冲突, 也可称之为二义性问题 发生二义性的两种情况 : 名称冲突 : 派生类在访问基类成员 ( 成员函数和成员变量 ) 时, 由于基类存在同名的成员, 导致无法确定访问的是哪个基类的成员, 因此出现了二义性错误 歧义基类 : 当一个派生类从多个基类派生时, 而这些基类又有一个共同的基类, 当对这个共同的基类中说明的成员进行访问时, 可能出现二义性问题 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

6 访问冲突 访问冲突 派生类在访问基类成员函数时, 由于基类存在同名的成员函数, 导致无法确定访问的是哪个基类的成员函数, 因此出现了二义性错误 例程 : 1 class Base1 2 { 3 public: 4 void fun() { cout<<"base1 "<<endl; } 5 }; 6 class Base2 7 { 8 public: 9 void fun() { cout<<"base2 "<<endl; } 10 }; 11 class Derived : public Base1, public Base2 12 { 13 }; 14 int main() 15 { 16 Derived obj; 17 obj.fun(); // 产生歧义无法确定访问的是继承自 Base1 的还是 Base2 的 18 return 0; 19 } Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

7 访问冲突 访问冲突 派生类在访问基类成员变量时, 由于基类存在同名的成员变量, 导致无法确定访问的是哪个基类的成员变量, 因此出现了二义性错误 例程 : 1 class BaseA 2 { 3 protected: 4 int data; // 出现一次 5 public: 6 BaseA(int d) { data=d; } 7 function(int num) {...}; 8 }; 1 class BaseB 2 { 3 protected: 4 int data; // 出现一次 5 public: 6 BaseB(int d) { data=d; } 7 function(int num) {...}; 8 }; 1 class Derived : public BaseA, public BaseB // 公有继承基类 2 { 3 public: 4 Derived(int a, int b) : BaseA(a), BaseB(b) 5 { data=function(a)+function(b); } // 访问 function 出现了二义性 6 void SetData(int d_loc) { data=d_loc; } // 访问 data 出现了二义性 7 } 名称冲突 : 当不同基类中出现同名的成员函数或成员变量时, 在派生类中访问这种成员函数或成员变量就会出现名称访问的二义性 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

8 访问冲突 访问冲突 Question 派生类在访问基类成员变量时, 由于基类存在同名的成员变量, 导致无法确请问定访问的是哪个基类的成员变量 : 一个 Derived 的对象有多少个成员变量和成员函数, 因此出现了二义性错误 例程? : 1 class BaseA 2 { 3 protected: 4 int data; // 出现一次 5 public: 6 BaseA(int d) { data=d; } 7 function(int num) {...}; 8 }; 1 class BaseB 2 { 3 protected: 4 int data; // 出现一次 5 public: 6 BaseB(int d) { data=d; } 7 function(int num) {...}; 8 }; 1 class Derived : public BaseA, public BaseB // 公有继承基类 2 { 3 public: 4 Derived(int a, int b) : BaseA(a), BaseB(b) 5 { data=function(a)+function(b); } // 访问 function 出现了二义性 6 void SetData(int d_loc) { data=d_loc; } // 访问 data 出现了二义性 7 } 名称冲突 : 当不同基类中出现同名的成员函数或成员变量时, 在派生类中访问这种成员函数或成员变量就会出现名称访问的二义性 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

9 访问冲突 访问冲突 当一个派生类从多个基类派生时, 而这些基类又有一个共同的基类, 当对这个共同的基类中说明的成员进行访问时, 可能出现二义性问题 1 class Base 2 { 3 public: 4 int data; 5 }; 6 class DerivedA : public Base 7 { }; 8 class DerivedB : public Base 9 { }; 10 class DerivedD : public DerivedA, public DerivedB 11 { }; int main() 14 { 15 DerivedD obj; 16 obj.data = 1; // 产生二义性 17 return 0; 18 } Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

10 访问冲突 访问冲突 当一个派生类从多个基类派生时, 而这些基类又有一个共同的基类, 当对这个共同的基类中说明的成员进行访问时, 可能出现二义性问题 1 class Base 2 { 3 public: 4 int data; 5 }; 6 class DerivedA : public Base 7 { }; 8 class DerivedB : public Base 9 { }; 10 class DerivedD : public DerivedA, public DerivedB 11 { }; int main() 14 { 15 DerivedD obj; 16 obj.data = 1; // 产生二义性 17 return 0; 18 } 请问 : 一个 DerivedD 的对象有多少个成员变量?sizeof(obj) 是多少? Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

11 访问冲突的解决办法 访问冲突 访问冲突 ( 二义性 ) 的解决办法 在定义基类时, 保证一个基类中的成员名与另一个基类中的成员名绝不相同 ( 极难做到 根本做不到 ) 在派生类中使用作用域运算符限定所访问的成员是属于哪一个基类的, 其格式为 < 基类名称 :: 成员名称 > 1 class Derived : public BaseA, public BaseB // 公有继承基类 2 { 3 public: 4 Derived(int a, int b) : BaseA(a), BaseB(b) 5 { 6 data = BaseA::function(a) // 解决了二义性问题 7 + BaseB::function(b); // 解决了二义性问题 8 } 9 void SetData(int d_loc) 10 { 11 BaseA::data=d_loc; // 解决了二义性问题 12 BaseB::data=d_loc; // 解决了二义性问题 13 } 14 } Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

12 访问冲突的解决办法 访问冲突 当把派生类作为基类, 又派生出新的派生类时, 这种限定作用域的运算符不能连续嵌套使用, 如下形式的使用方式是不允许的 : < 类名 1> :: < 类名 2> :: < 类名 n> :: < 类名 N> :: < 成员名 > 由于 C++ 是通过作用域运算符来解决访问二义性问题, 因此规定任一基类在派生类中只能被直接继承一次, 否则会造成成员名访问的冲突 例如 : 1 class A 2 { 3 public: 4 float data; }; 7 class B: public A, public A // 错误的 8 { }; B 类的定义是错误的 假如允许基类被直接继承一次以上, 那么通过作用域运算符就无法解决访问二义性 ( 访问冲突 ) 问题 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

13 提纲 支配规则 1 访问冲突 2 支配规则 3 虚基类与构造函数 4 赋值兼容及其限制 5 总结与思考 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

14 支配规则 支配规则 支配规则 : 当通过派生类的对象访问基类和派生类中的同名成员时, 派生类的成员被优先访问 ( 可理解为 就近 访问 ) 1 class A 2 { 3 protected: int x; 4 public: 5 void Set(int a) 6 { x=a; } 7 void Show( ) 8 { 9 cout <<"x=" <<x <<endl; 10 } 11 }; 12 class B : public A 13 { 14 protected: 15 int x; 16 public: 17 void SetAx(int a) 程序输出结果 : x=1 x=2 18 { A::x=a; }// 基类 A 的 19 void SetBx(int a) 20 { x = a; }// 派生类 B 的 21 void Show( ) 22 { 23 cout<<"x=" <<x <<endl; 24 } 25 }; 26 int main(void) 27 { 28 B b; 29 b.setax(1); 30 b.setbx(2); 31 b.a::show( ); // 基类 A 的 32 b.show( ); // 派生类 B 的 33 return 0; 34 } Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

15 支配规则 支配规则 支配规则 : 当通过派生类的对象访问基类和派生类中的同名成员时, 派生类的成员被优先访问 ( 可理解为 就近 访问 ) 1 class A 2 { 3 protected: int x; 4 public: 5 void Set(int a) 6 { x=a; } 7 void Show( ) 8 { 9 cout <<"x=" <<x <<endl; 10 } 11 }; 12 class B : public A 13 { 14 protected: 15 int x; 16 public: 17 void SetAx(int a) 程序输出结果 : x=1 x=2 18 { A::x=a; }// 基类 A 的 19 void SetBx(int a) 20 { x = a; }// 派生类 B 的 21 void Show( ) 22 { 23 cout<<"x=" <<x <<endl; 24 } 25 }; 26 int main(void) 27 { 28 B b; 29 b.setax(1); 30 b.setbx(2); 31 b.a::show( ); // 基类 A 的 32 b.show( ); // 派生类 B 的 33 return 0; 34 } 请问 : 类 B 的一个对象有多少个数据成员? Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

16 支配规则 支配规则 同名隐藏 : 派生类中具有和基类同名的函数 ( 不管参数 ) 时, 派生类的该方法将会隐藏掉所有的基类的同名方法 1 class Base 2 { 3 public: 4 Base() {} 5 ~Base() {} 6 public: 7 void show() 8 {cout<<"base::show()\n"; } 9 void show(int x) 10 {cout<<"base::show(int)\n";} 11 }; 12 class D : public Base 13 { 14 public: 15 D() {} 16 ~D() {} 删除出错行, 18 public: 19 void show() 20 { cout <<"D::show()\n"; } 21 }; int main() 24 { 25 D d; 26 d.show( ); // 此处调用的 是 D 类中的 show() 方法 27 d.show(2); // 28 return 0; 29 } Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

17 支配规则 支配规则 同名隐藏 : 派生类中具有和基类同名的函数 ( 不管参数 ) 时, 派生类的该方法将会隐藏掉所有的基类的同名方法 1 class Base 2 { 3 public: 4 Base() {} 5 ~Base() {} 6 public: 7 void show() 8 {cout<<"base::show()\n"; } 9 void show(int x) 10 {cout<<"base::show(int)\n";} 11 }; 12 class D : public Base 13 { 14 public: 15 D() {} 16 ~D() {} 删除出错行, 18 public: 19 void show() 20 { cout <<"D::show()\n"; } 21 }; int main() 24 { 25 D d; 26 d.show( ); // 此处调用的 是 D 类中的 show() 方法 27 d.show(2); // 出错, 因为派生 类中的 show() 隐藏了基类中所有 同名方法, 而派生类中没有带参数 的 show() 方法 28 return 0; 29 } Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

18 支配规则 支配规则 同名隐藏 : 派生类中具有和基类同名的函数 ( 不管参数 ) 时, 派生类的该方法将会隐藏掉所有的基类的同名方法 1 class Base 2 { 3 public: 4 Base() {} 5 ~Base() {} 6 public: 7 void show() 8 {cout<<"base::show()\n"; } 9 void show(int x) 10 {cout<<"base::show(int)\n";} 11 }; 12 class D : public Base 13 { 14 public: 15 D() {} 16 ~D() {} 删除出错行, 则程序输出结果为 :D::show() 18 public: 19 void show() 20 { cout <<"D::show()\n"; } 21 }; int main() 24 { 25 D d; 26 d.show( ); // 此处调用的 是 D 类中的 show() 方法 27 d.show(2); // 出错, 因为派生 类中的 show() 隐藏了基类中所有 同名方法, 而派生类中没有带参数 的 show() 方法 28 return 0; 29 } Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

19 支配规则 支配规则 同名隐藏 : 派生类中具有和基类同名的函数 ( 不管参数 ) 时, 派生类的该方法将会隐藏掉所有的基类的同名方法 1 class Base 2 { 3 public: 4 Base() {} 5 ~Base() {} 6 public: 7 void show() 8 {cout<<"base::show()\n"; } 9 void show(int x) 10 {cout<<"base::show(int)\n";} 11 }; 12 class D : public Base 13 { 14 public: 15 D() {} 16 ~D() {} 18 public: 19 void show() 20 { cout <<"D::show()\n"; } 21 }; int main() 24 { 25 D d; 26 d.show( ); // 此处调用的 是 D 类中的 show() 方法 27 d.show(2); // 出错, 因为派生 类中的 show() 隐藏了基类中所有 同名方法, 而派生类中没有带参数 的 show() 方法 28 return 0; 29 } 删除出错行, 则程序输出结果为 :D::show() 若未特别指明, 则通过派生类对象使用的都是派生类中的同名成员 ; Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

20 支配规则 支配规则 同名隐藏 : 派生类中具有和基类同名的函数 ( 不管参数 ) 时, 派生类的该方法将会隐藏掉所有的基类的同名方法 1 class Base 2 { 3 public: 4 Base() {} 5 ~Base() {} 6 public: 7 void show() 8 {cout<<"base::show()\n"; } 9 void show(int x) 10 {cout<<"base::show(int)\n";} 11 }; 12 class D : public Base 13 { 14 public: 15 D() {} 16 ~D() {} 18 public: 19 void show() 20 { cout <<"D::show()\n"; } 21 }; int main() 24 { 25 D d; 26 d.show( ); // 此处调用的 是 D 类中的 show() 方法 27 d.base::show(2);// 28 return 0; 29 } 删除出错行, 则程序输出结果为 :D::show() 若未特别指明, 则通过派生类对象使用的都是派生类中的同名成员 ; 如要通过派生类对象访问基类中被屏蔽的同名成员, 应使用基类名限定访问被隐藏方法 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

21 支配规则 支配规则 同名隐藏 : 派生类中具有和基类同名的函数 ( 不管参数 ) 时, 派生类的该方法将会隐藏掉所有的基类的同名方法 1 class Base 2 { 3 public: 4 Base() {} 5 ~Base() {} 6 public: 7 void show() 8 {cout<<"base::show()\n"; } 9 void show(int x) 10 {cout<<"base::show(int)\n";} 11 }; 12 class D : public Base 13 { 14 public: 15 D() {} 16 ~D() {} 18 public: 19 void show() 20 { cout <<"D::show()\n"; } 21 }; int main() 24 { 25 D d; 26 d.show( ); // 此处调用的 是 D 类中的 show() 方法 27 d.base::show(2);// 正确, 因为 派生类中的 show() 隐藏了基类中 所有同名方法, 应使用基类名限定 访问被隐藏方法 28 return 0; 29 } 删除出错行, 则程序输出结果为 :D::show() 若未特别指明, 则通过派生类对象使用的都是派生类中的同名成员 ; 如要通过派生类对象访问基类中被屏蔽的同名成员, 应使用基类名限定访问被隐藏方法 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

22 支配规则 支配规则 同名隐藏 : 派生类中具有和基类同名的函数 ( 不管参数 ) 时, 派生类的该方法将会隐藏掉所有的基类的同名方法 1 class Base 2 { 3 public: 4 Base() {} 5 ~Base() {} 6 public: 7 void show() 8 {cout<<"base::show()\n"; } 9 void show(int x) 10 {cout<<"base::show(int)\n";} 11 }; 12 class D : public Base 13 { 14 public: 15 D() {} 16 ~D() {} 18 public: 19 void show() 20 { cout <<"D::show()\n"; } 21 }; int main() 24 { 25 D d; 26 d.show( ); // 此处调用的 是 D 类中的 show() 方法 27 d.base::show(2);// 正确, 因为 派生类中的 show() 隐藏了基类中 所有同名方法, 应使用基类名限定 访问被隐藏方法 28 return 0; 29 } 删除出错行程序输出结果, 则程序输出结果为? :D::show() 若未特别指明, 则通过派生类对象使用的都是派生类中的同名成员 ; 如要通过派生类对象访问基类中被屏蔽的同名成员, 应使用基类名限定访问被隐藏方法 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

23 支配规则 支配规则 同名隐藏 : 派生类中具有和基类同名的函数 ( 不管参数 ) 时, 派生类的该方法将会隐藏掉所有的基类的同名方法 1 class Base 2 { 3 public: 4 Base() {} 5 ~Base() {} 6 public: 7 void show() 8 {cout<<"base::show()\n"; } 9 void show(int x) 10 {cout<<"base::show(int)\n";} 11 }; 12 class D : public Base 13 { 14 public: 15 D() {} 16 ~D() {} 18 public: 19 void show() 20 { cout <<"D::show()\n"; } 21 }; int main() 24 { 25 D d; 26 d.show( ); // 此处调用的 是 D 类中的 show() 方法 27 d.base::show(2);// 正确, 因为 派生类中的 show() 隐藏了基类中 所有同名方法, 应使用基类名限定 访问被隐藏方法 28 return 0; 29 } 删除出错行程序输出结果, 则程序输出结果为? D::show() :D::show() 若未特别指明, 则通过派生类对象使用的都是派生类中的同名成员 Base::show(int) ; 如要通过派生类对象访问基类中被屏蔽的同名成员, 应使用基类名限定访问被隐藏方法 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

24 提纲 虚基类与构造函数 1 访问冲突 2 支配规则 3 虚基类与构造函数 4 赋值兼容及其限制 5 总结与思考 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

25 虚基类与构造函数虚 (virtual) 基类 在下面公有继承关系中, 在类 D 中包含了基类 A 的两个拷贝 ( 副本 ) 在类 D 的成员函数中, 欲访问 A 的成员 x, 则必须以 B::x 和 C::x 区分 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

26 虚基类与构造函数虚 (virtual) 基类 在下面公有继承关系中, 在类 D 中包含了基类 A 的两个拷贝 ( 副本 ) 在类 D 的成员函数中, 欲访问 A 的成员 x, 则必须以 B::x 和 C::x 区分 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

27 虚基类与构造函数虚 (virtual) 基类 在下面公有继承关系中, 在类 D 中包含了基类 A 的两个拷贝 ( 副本 ) 在类 D 的成员函数中, 欲访问 A 的成员 x, 则必须以 B::x 和 C::x 区分 Figure: Non-virtual vs Virtual derivation chains 若欲使公共的基类 A 在派生类中只有一个拷贝 ( 副本 ), 可将 A 说明成虚 (virtual) 基类 继承时, 在基类的类名前加上关键词 :virtual Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

28 虚基类与构造函数虚 (virtual) 基类和赋值兼容 1 class A 2 { 3 protected: 4 int x; 5 public: 6 A (int a=0) { x=a; } 7 }; 8 class B : virtual public A 9 { 10 protected: 11 int y; 12 public: 13 B(int a=0, int b=0) : A(a) 14 { y=b; } 15 }; 16 class C : public virtual A 17 { 18 protected: 19 int z; 20 public: 21 C(int a=0, int c=0) : A(a) 22 { z=c; } 23 }; 24 class D : public B, public C 25 { 26 protected: 27 int k; 28 public: 29 D(int a1=0, int a2=0, int b =0, int c=0, int d=0) : B(a1, b), C(a2, c), k(d) 30 { } 31 void Show( ) 32 { 33 cout << "x=" << x << ", "; 34 cout << "y=" << y << ", "; 35 cout << "z=" << z << ", "; 36 cout << "k=" << k << endl; 37 } 38 }; Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

29 虚基类与构造函数虚 (virtual) 基类和赋值兼容 1 class A 2 { 3 protected: 4 int x; 5 public: 6 A (int a=0) { x=a; } 7 }; 8 class B : virtual public A 9 { 10 protected: 11 int y; 12 public: 13 B(int a=0, int b=0) : A(a) 14 { y=b; } 15 }; 16 class C : public virtual A 17 { 18 protected: 19 int z; 20 public: 21 C(int a=0, int c=0) : A(a) 22 { z=c; } 23 }; 24 class D : public B, public C 25 { 26 protected: 27 int k; 28 public: 29 D(int a1=0, int a2=0, int b =0, int c=0, int d=0) : B(a1, b), C(a2, c), k(d) 30 { } 31 void Show( ) 32 { 33 cout << "x=" << x << ", "; 34 cout << "y=" << y << ", "; 35 cout << "z=" << z << ", "; 36 cout << "k=" << k << endl; 37 } 38 }; 请写出代码段 D obj(1, 1, 2, 3, 4); obj.show( ); 的运行结果 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

30 虚基类与构造函数虚 (virtual) 基类和赋值兼容 提示 : 编译器会隐式地调用基类 A 的默认构造函数 类 D 有多少个对象成员? 1 class A 21 C(int a=0, int c=0) : A(a) 2 { 22 { z=c; } 3 protected: 23 }; 4 int x; 24 class D : public B, public C 5 public: 25 { 6 A (int a=0) { x=a; } 26 protected: 7 }; 27 int k; 8 class B : virtual public A 28 public: 9 { 29 D(int a1=0, int a2=0, int b 10 protected: =0, int c=0, int d=0) : B(a1 11 int y;, b), C(a2, c), k(d) 12 public: 30 { } 13 B(int a=0, int b=0) : A(a) 31 void Show( ) 14 { y=b; } 32 { 15 }; 33 cout << "x=" << x << ", "; 16 class C : public virtual A 34 cout << "y=" << y << ", "; 17 { 35 cout << "z=" << z << ", "; 18 protected: 36 cout << "k=" << k << endl; 19 int z; 37 } 20 public: 38 }; 请写出代码段 D obj(1, 1, 2, 3, 4); obj.show( ); 的运行结果 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

31 虚基类与构造函数虚 (virtual) 基类和赋值兼容 39 int main(void) 40 { 41 D obj(1, 1, 2, 3, 4); obj.show( ); 42 int n(0); A obja; B objb; C objc; 43 cout << "size of n is: " << sizeof(n)<<endl; 44 cout << "size of obj A is: " << sizeof(obja)<<endl; 45 cout << "size of obj B is: " << sizeof(objb)<<endl; 46 cout << "size of obj C is: " << sizeof(objc)<<endl; 47 cout << "size of obj D is: " << sizeof(obj) <<endl; 48 return 0; 49 } 程序的运行结果是 : x=0, y=2, z=3, k=4 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

32 虚基类与构造函数虚 (virtual) 基类和赋值兼容 39 int main(void) 40 { 41 D obj(1, 1, 2, 3, 4); obj.show( ); 42 int n(0); A obja; B objb; C objc; 43 cout << "size of n is: " << sizeof(n)<<endl; 44 cout << "size of obj A is: " << sizeof(obja)<<endl; 45 cout << "size of obj B is: " << sizeof(objb)<<endl; 46 cout << "size of obj C is: " << sizeof(objc)<<endl; 47 cout << "size of obj D is: " << sizeof(obj) <<endl; 48 return 0; 49 } 程序的运行结果是 : x=0, y=2, z=3, k=4 size of n is: 4 size of obj A is: 16 size of obj B is: 16 size of obj C is: 16 size of obj D is: 40 构造函数的调用顺序 : Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

33 虚基类与构造函数虚 (virtual) 基类和赋值兼容 39 int main(void) 40 { 41 D obj(1, 1, 2, 3, 4); obj.show( ); 42 int n(0); A obja; B objb; C objc; 43 cout << "size of n is: " << sizeof(n)<<endl; 44 cout << "size of obj A is: " << sizeof(obja)<<endl; 45 cout << "size of obj B is: " << sizeof(objb)<<endl; 46 cout << "size of obj C is: " << sizeof(objc)<<endl; 47 cout << "size of obj D is: " << sizeof(obj) <<endl; 48 return 0; 49 } 程序的运行结果是 : x=0, y=2, z=3, k=4 size of n is: 4 size of obj A is: 16 size of obj B is: 16 size of obj C is: 16 size of obj D is: 40 构造函数的调用顺序 : 先调用虚基类的构造函数, 再调用非虚基类的构造函数 ; 构造函数调用时, 系统按照继承关系 ( 定义时 ) 的顺序调用 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

34 虚基类与构造函数虚 (virtual) 基类和赋值兼容 如将 29 行改为 29 D(int a1=0, int a2=0, int b=0, int c=0, int d=0) : A(a1), B(a1, b), C(a2, c), k(d) 30 { } 回顾第 44 行 41 D obj(1, 1, 2, 3, 4); obj.show( ); 则程序的运行结果变为 : x=1, y=2, z=3, k=4 size of n is: 4 size of obj A is: 16 size of obj B is: 16 size of obj C is: 16 size of obj D is: 40 构造函数的调用顺序仍然是 : 先调用虚基类的构造函数, 再调用非虚基类的构造函数, 并按照继承关系 ( 定义时 ) 的顺序调用 关于 virtual public 后类的对象之大小, 感兴趣的同学请参考 深入探索 C++ 对象模型 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

35 虚基类与构造函数虚 (virtual) 基类和赋值兼容 在多重继承中, 派生类的构造函数负责该派生类所有基类构造函数以及对象成员 ( 如果有的话 ) 构造函数的调用 派生类构造函数执行顺序如下 : 先调用基类构造函数, 再调用派生类构造函数 ; 先初始化所包含的对象成员, 后初始化普通类型数据成员, 最后执行派生类本身的构造函数 多个基类构造函数的执行顺序取决于定义派生类时的顺序, 与派生类在构造函数中成员初始化列表中的顺序无关 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

36 虚基类与构造函数虚 (virtual) 基类和赋值兼容 在多重继承中, 派生类的构造函数负责该派生类所有基类构造函数以及对象成员 ( 如果有的话 ) 构造函数的调用 派生类构造函数执行顺序如下 : 先调用基类构造函数, 再调用派生类构造函数 ; 先初始化所包含的对象成员, 后初始化普通类型数据成员, 最后执行派生类本身的构造函数 多个基类构造函数的执行顺序取决于定义派生类时的顺序, 与派生类在构造函数中成员初始化列表中的顺序无关 在多重继承中, 派生类有多个基类, 如果有些是虚基类有些是非虚基类, 那么构造函数的调用顺序是 : 无论虚基类与产生对象的派生类相隔多远, 先调用虚基类的构造函数, 再按继承次序调用直接基类的构造函数 ; 当同一层有多个虚基类, 按照继承关系定义的顺序调用它们的构造函数 ; 如果包含类的对象成员, 则按声明次序调用对象成员所属类的构造函数, 然后初始化普通类型数据成员, 最后执行派生类本身的构造函数 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

37 虚基类与构造函数虚 (virtual) 基类和赋值兼容 在多重继承中, 派生类的构造函数负责该派生类所有基类构造函数以及对象成员 ( 如果有的话 ) 构造函数的调用 派生类构造函数执行顺序如下 : 先调用基类构造函数, 再调用派生类构造函数 ; 先初始化所包含的对象成员, 后初始化普通类型数据成员, 最后执行派生类本身的构造函数 多个基类构造函数的执行顺序取决于定义派生类时的顺序, 与派生类在构造函数中成员初始化列表中的顺序无关 在多重继承中, 派生类有多个基类, 如果有些是虚基类有些是非虚基类, 那么构造函数的调用顺序是 : 无论虚基类与产生对象的派生类相隔多远, 先调用虚基类的构造函数, 再按继承次序调用直接基类的构造函数 ; 当同一层有多个虚基类, 按照继承关系定义的顺序调用它们的构造函数 ; 如果包含类的对象成员, 则按声明次序调用对象成员所属类的构造函数, 然后初始化普通类型数据成员, 最后执行派生类本身的构造函数 1 class X : public Y, virtual public Z { } object; 当产生类 X 的对象 object 时, 将产生如下调用顺序 : Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

38 虚基类与构造函数虚 (virtual) 基类和赋值兼容 在多重继承中, 派生类的构造函数负责该派生类所有基类构造函数以及对象成员 ( 如果有的话 ) 构造函数的调用 派生类构造函数执行顺序如下 : 先调用基类构造函数, 再调用派生类构造函数 ; 先初始化所包含的对象成员, 后初始化普通类型数据成员, 最后执行派生类本身的构造函数 多个基类构造函数的执行顺序取决于定义派生类时的顺序, 与派生类在构造函数中成员初始化列表中的顺序无关 在多重继承中, 派生类有多个基类, 如果有些是虚基类有些是非虚基类, 那么构造函数的调用顺序是 : 无论虚基类与产生对象的派生类相隔多远, 先调用虚基类的构造函数, 再按继承次序调用直接基类的构造函数 ; 当同一层有多个虚基类, 按照继承关系定义的顺序调用它们的构造函数 ; 如果包含类的对象成员, 则按声明次序调用对象成员所属类的构造函数, 然后初始化普通类型数据成员, 最后执行派生类本身的构造函数 1 class X : public Y, virtual public Z { } object; 当产生类 X 的对象 object 时, 将产生如下调用顺序 :Z() >Y() >X() Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

39 虚基类与构造函数虚 (virtual) 基类和赋值兼容 最远基类成员原则 : 无论虚基类与产生对象的派生类相隔多远, 先调用虚基类的构造函数, 再按继承次序调用直接基类的构造函数 1 class B0 2 { 3 public: 4 int nv0; 5 void fun() 6 { cout<<"member of B0\n"; } 7 }; 8 class B1: virtual public B0 9 { 10 public: 11 int nv1; 12 }; 13 class B2: virtual public B0 14 { 15 public: 16 int nv2; 17 }; 当产生对象 D1 时, 构造函数调用次序 : 18 class D1: public B1, public B2 19 { 20 public: 21 int nvd; 22 void fun() // 隐藏基类同名函数 23 { cout<<"member of D1\n"; } 24 }; 25 int main() 26 { 27 D1 d1; 28 d1.nv0=2; // 使用最远基类成员 29 d1.fun(); 30 return 0; 31 } 运行结果 : Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

40 虚基类与构造函数虚 (virtual) 基类和赋值兼容 最远基类成员原则 : 无论虚基类与产生对象的派生类相隔多远, 先调用虚基类的构造函数, 再按继承次序调用直接基类的构造函数 1 class B0 2 { 3 public: 4 int nv0; 5 void fun() 6 { cout<<"member of B0\n"; } 7 }; 8 class B1: virtual public B0 9 { 10 public: 11 int nv1; 12 }; 13 class B2: virtual public B0 14 { 15 public: 16 int nv2; 17 }; 当产生对象 D1 时, 构造函数调用次序 : 18 class D1: public B1, public B2 19 { 20 public: 21 int nvd; 22 void fun() // 隐藏基类同名函数 23 { cout<<"member of D1\n"; } 24 }; 25 int main() 26 { 27 D1 d1; 28 d1.nv0=2; // 使用最远基类成员 29 d1.fun(); 30 return 0; 31 } 运行结果 : Member of D1 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

41 虚基类与构造函数虚 (virtual) 基类和赋值兼容 最远基类成员原则 : 无论虚基类与产生对象的派生类相隔多远, 先调用虚基类的构造函数, 再按继承次序调用直接基类的构造函数 1 class B0 2 { 3 public: 4 int nv0; 5 void fun() 6 { cout<<"member of B0\n"; } 7 }; 8 class B1: virtual public B0 9 { 10 public: 11 int nv1; 12 }; 13 class B2: virtual public B0 14 { 15 public: 16 int nv2; 17 }; 当产生对象 D1 时, 构造函数调用次序 :B0() 18 class D1: public B1, public B2 19 { 20 public: 21 int nvd; 22 void fun() // 隐藏基类同名函数 23 { cout<<"member of D1\n"; } 24 }; 25 int main() 26 { 27 D1 d1; 28 d1.nv0=2; // 使用最远基类成员 29 d1.fun(); 30 return 0; 31 } 运行结果 : Member of D1 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

42 虚基类与构造函数虚 (virtual) 基类和赋值兼容 最远基类成员原则 : 无论虚基类与产生对象的派生类相隔多远, 先调用虚基类的构造函数, 再按继承次序调用直接基类的构造函数 1 class B0 2 { 3 public: 4 int nv0; 5 void fun() 6 { cout<<"member of B0\n"; } 7 }; 8 class B1: virtual public B0 9 { 10 public: 11 int nv1; 12 }; 13 class B2: virtual public B0 14 { 15 public: 16 int nv2; 17 }; 当产生对象 D1 时, 构造函数调用次序 :B0() B1() 18 class D1: public B1, public B2 19 { 20 public: 21 int nvd; 22 void fun() // 隐藏基类同名函数 23 { cout<<"member of D1\n"; } 24 }; 25 int main() 26 { 27 D1 d1; 28 d1.nv0=2; // 使用最远基类成员 29 d1.fun(); 30 return 0; 31 } 运行结果 : Member of D1 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

43 虚基类与构造函数虚 (virtual) 基类和赋值兼容 最远基类成员原则 : 无论虚基类与产生对象的派生类相隔多远, 先调用虚基类的构造函数, 再按继承次序调用直接基类的构造函数 1 class B0 2 { 3 public: 4 int nv0; 5 void fun() 6 { cout<<"member of B0\n"; } 7 }; 8 class B1: virtual public B0 9 { 10 public: 11 int nv1; 12 }; 13 class B2: virtual public B0 14 { 15 public: 16 int nv2; 17 }; 18 class D1: public B1, public B2 19 { 20 public: 21 int nvd; 22 void fun() // 隐藏基类同名函数 23 { cout<<"member of D1\n"; } 24 }; 25 int main() 26 { 27 D1 d1; 28 d1.nv0=2; // 使用最远基类成员 29 d1.fun(); 30 return 0; 31 } 运行结果 : Member of D1 当产生对象 D1 时, 构造函数调用次序 :B0() B1() B2() Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

44 虚基类与构造函数虚 (virtual) 基类和赋值兼容 最远基类成员原则 : 无论虚基类与产生对象的派生类相隔多远, 先调用虚基类的构造函数, 再按继承次序调用直接基类的构造函数 1 class B0 2 { 3 public: 4 int nv0; 5 void fun() 6 { cout<<"member of B0\n"; } 7 }; 8 class B1: virtual public B0 9 { 10 public: 11 int nv1; 12 }; 13 class B2: virtual public B0 14 { 15 public: 16 int nv2; 17 }; 18 class D1: public B1, public B2 19 { 20 public: 21 int nvd; 22 void fun() // 隐藏基类同名函数 23 { cout<<"member of D1\n"; } 24 }; 25 int main() 26 { 27 D1 d1; 28 d1.nv0=2; // 使用最远基类成员 29 d1.fun(); 30 return 0; 31 } 运行结果 : Member of D1 当产生对象 D1 时, 构造函数调用次序 :B0() B1() B2() D1() Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

45 虚基类与构造函数虚 (virtual) 基类和赋值兼容 最远基类成员原则 : 无论虚基类与产生对象的派生类相隔多远, 先调用虚基类的构造函数, 再按继承次序调用直接基类的构造函数 1 class B0 2 { 3 public: 4 int nv0; 5 void fun() 6 { cout<<"member of B0\n"; } 7 }; 8 class B1: virtual public B0 9 { 10 public: 11 int nv1; 12 }; 13 class B2: virtual public B0 14 { 15 public: 16 int nv2; 17 }; 18 class D1: public B1, public B2 19 { 20 public: 21 int nvd; 22 void fun() // 隐藏基类同名函数 23 { cout<<"member of D1\n"; } 24 }; 25 int main() 26 { 27 D1 d1; 28 d1.nv0=2; // 使用最远基类成员 29 d1.fun(); 30 return 0; 31 } 运行结果 : Member of D1 当产生对象 D1 时, 构造函数调用次序 :B0() B1() B2() D1() 此时, 调用的是基类与派生类的默认构造函数 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

46 虚基类与构造函数虚 (virtual) 基类和赋值兼容 请写出如下多重继承中构造函数的调用顺序 1 class base1 2 { 3 }; 4 class base2 5 { 6 }; 7 class level1 : public base2, virtual public base1 // 8 { 9 }; 10 class level2 : public base2, virtual public base1 // 11 { 12 }; 13 class toplevel1 : public level1, virtual public level2 14 { 15 }; 16 toplevel1 view; 当产生对象 view 时, 函数调用次序 : Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

47 虚基类与构造函数虚 (virtual) 基类和赋值兼容 请写出如下多重继承中构造函数的调用顺序 1 class base1 2 { 3 }; 4 class base2 5 { 6 }; 7 class level1 : public base2, virtual public base1 // 8 { 9 }; 10 class level2 : public base2, virtual public base1 // 11 { 12 }; 13 class toplevel1 : public level1, virtual public level2 14 { 15 }; 16 toplevel1 view; 当产生对象 view 时, 函数调用次序 : base1() base2() Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

48 虚基类与构造函数虚 (virtual) 基类和赋值兼容 请写出如下多重继承中构造函数的调用顺序 1 class base1 2 { 3 }; 4 class base2 5 { 6 }; 7 class level1 : public base2, virtual public base1 // 8 { 9 }; 10 class level2 : public base2, virtual public base1 // 11 { 12 }; 13 class toplevel1 : public level1, virtual public level2 14 { 15 }; 16 toplevel1 view; 当产生对象 view 时, 函数调用次序 : base1() base2() level2() Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

49 虚基类与构造函数虚 (virtual) 基类和赋值兼容 请写出如下多重继承中构造函数的调用顺序 1 class base1 2 { 3 }; 4 class base2 5 { 6 }; 7 class level1 : public base2, virtual public base1 // 8 { 9 }; 10 class level2 : public base2, virtual public base1 // 11 { 12 }; 13 class toplevel1 : public level1, virtual public level2 14 { 15 }; 16 toplevel1 view; 当产生对象 view 时, 函数调用次序 : base1() base2() level2() base2() Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

50 虚基类与构造函数虚 (virtual) 基类和赋值兼容 请写出如下多重继承中构造函数的调用顺序 1 class base1 2 { 3 }; 4 class base2 5 { 6 }; 7 class level1 : public base2, virtual public base1 // 8 { 9 }; 10 class level2 : public base2, virtual public base1 // 11 { 12 }; 13 class toplevel1 : public level1, virtual public level2 14 { 15 }; 16 toplevel1 view; 当产生对象 view 时, 函数调用次序 : base1() base2() level2() base2() level1() toplevel1() Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

51 虚基类与构造函数虚 (virtual) 基类和赋值兼容 请写出如下多重继承中构造函数的调用顺序 1 class base1 2 { 3 }; 4 class base2 5 { 6 }; 7 class level1 : public base2, virtual public base1 // 8 { 9 }; 10 class level2 : public base2, virtual public base1 // base1 是虚基类, 在这 里执行其构造函数 11 { 12 }; 13 class toplevel1 : public level1, virtual public level2 14 { 15 }; 16 toplevel1 view; 当产生对象 view 时, 函数调用次序 : base1() base2() level2() base2() level1() toplevel1() Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

52 虚基类与构造函数虚 (virtual) 基类和赋值兼容 请写出如下多重继承中构造函数的调用顺序 1 class base1 2 { 3 }; 4 class base2 5 { 6 }; 7 class level1 : public base2, virtual public base1 // base1 是虚基类, 无需再执行其构造函数 8 { 9 }; 10 class level2 : public base2, virtual public base1 // base1 是虚基类, 在这里执行其构造函数 11 { 12 }; 13 class toplevel1 : public level1, virtual public level2 14 { 15 }; 16 toplevel1 view; 当产生对象 view 时, 函数调用次序 : base1() base2() level2() base2() level1() toplevel1() Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

53 提纲 赋值兼容及其限制 1 访问冲突 2 支配规则 3 虚基类与构造函数 4 赋值兼容及其限制 5 总结与思考 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

54 赋值兼容及其限制赋值兼容及其限制 赋值 赋值兼容规则不同类型数据之间在一定条件下可以进行自动转换和赋值, 这称为赋值兼容 例如 1 int to double 在赋值之前, 把整型数据先转换成为双精度型数据, 但是不能把一个整型数据赋给指针变量 基类与派生类对象之间是否也有赋值兼容的关系, 可否进行类型间的转换? Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

55 赋值兼容及其限制赋值兼容及其限制 赋值 赋值兼容规则不同类型数据之间在一定条件下可以进行自动转换和赋值, 这称为赋值兼容 例如 1 int to double 在赋值之前, 把整型数据先转换成为双精度型数据, 但是不能把一个整型数据赋给指针变量 基类与派生类对象之间是否也有赋值兼容的关系, 可否进行类型间的转换? 基类与派生类对象之间有赋值兼容关系 因此, 可将派生类的值赋给基类对象, 在用到基类对象时可以用其子类对象代替 具体表现在以下几个方面 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

56 赋值兼容及其限制赋值兼容及其限制 赋值 赋值兼容规则不同类型数据之间在一定条件下可以进行自动转换和赋值, 这称为赋值兼容 例如 1 int to double 在赋值之前, 把整型数据先转换成为双精度型数据, 但是不能把一个整型数据赋给指针变量 基类与派生类对象之间是否也有赋值兼容的关系, 可否进行类型间的转换? 基类与派生类对象之间有赋值兼容关系 因此, 可将派生类的值赋给基类对象, 在用到基类对象时可以用其子类对象代替 具体表现在以下几个方面 派生类对象可以向基类对象赋值 可以用子类 ( 即公用派生类 ) 对象对其基类对象赋值 如 1 A a1; // 定义基类 A 对象 a1 2 B b1; // 定义类 A 的公用派生类 B 的对象 b1 3 a1=b1; // 用派生类 B 对象 b1 对基类对象 a1 赋值 实际上, 赋值只是对数据成员赋值, 类的成员函数不存在赋值问题 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

57 赋值兼容及其限制赋值兼容及其限制 引用 派生类对象可以替代基类对象向基类对象的引用进行赋值或初始化 例如, 已定义了基类 A 派生类 B 以及基类对象 a1, 可以定义 a1 的引用变量 : 1 A a1; // 定义基类 A 对象 a1 2 B b1; // 定义公用派生类 B 对象 b1 3 A& r=a1; // 定义基类 A 对象的引用变量 r, 并用 a1 对其初始化 这时, 引用变量 r 是 a1 的别名,r 和 a1 共享同一段存储单元 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

58 赋值兼容及其限制赋值兼容及其限制 引用 派生类对象可以替代基类对象向基类对象的引用进行赋值或初始化 例如, 已定义了基类 A 派生类 B 以及基类对象 a1, 可以定义 a1 的引用变量 : 1 A a1; // 定义基类 A 对象 a1 2 B b1; // 定义公用派生类 B 对象 b1 3 A& r=a1; // 定义基类 A 对象的引用变量 r, 并用 a1 对其初始化 这时, 引用变量 r 是 a1 的别名,r 和 a1 共享同一段存储单元 我们也可以用派生类的对象初始化引用变量 r, 即把上面最后一行改为 3 A& r=b1; // 定义基类 A 对象的引用变量 r, 并用派生类 B 对象 b1 对其初始化 或者保留上面第 3 行 A& r=a1;, 并对 r 重新赋值 4 r=b1; // 用派生类 B 对象 b1 对 a1 的引用变量 r 赋值 此时,r 并不是 b1 的别名, 也不与 b1 共享同一段存储单元 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

59 赋值兼容及其限制赋值兼容及其限制 引用 派生类对象可以替代基类对象向基类对象的引用进行赋值或初始化 例如, 已定义了基类 A 派生类 B 以及基类对象 a1, 可以定义 a1 的引用变量 : 1 A a1; // 定义基类 A 对象 a1 2 B b1; // 定义公用派生类 B 对象 b1 3 A& r=a1; // 定义基类 A 对象的引用变量 r, 并用 a1 对其初始化 这时, 引用变量 r 是 a1 的别名,r 和 a1 共享同一段存储单元 我们也可以用派生类的对象初始化引用变量 r, 即把上面最后一行改为 3 A& r=b1; // 定义基类 A 对象的引用变量 r, 并用派生类 B 对象 b1 对其初始化 或者保留上面第 3 行 A& r=a1;, 并对 r 重新赋值 4 r=b1; // 用派生类 B 对象 b1 对 a1 的引用变量 r 赋值 此时,r 并不是 b1 的别名, 也不与 b1 共享同一段存储单元 需要注意的是 :r 只是 b1 中基类部分的别名,r 与 b1 中基类部分共享同一段存储单元,r 与 b1 具有相同的起始地址 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

60 赋值兼容及其限制赋值兼容及其限制 引用 如果函数的参数是基类对象或基类对象的引用, 相应的函数实参可以使用派生类的对象 例如, 已定义了基类 A 派生类 B, 有一函数 1 void fun(a& r) // 形参是类 A 的对象的引用变量 2 { 3 cout<<r.num<<endl; // 输出该引用变量的数据成员 num 4 } 函数的形参是类 A 的对象的引用变量, 函数 fun 的实参应该为 A 类的对象 5 fun(a1); // 此处,a1 为类 A 的对象 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

61 赋值兼容及其限制赋值兼容及其限制 引用 如果函数的参数是基类对象或基类对象的引用, 相应的函数实参可以使用派生类的对象 例如, 已定义了基类 A 派生类 B, 有一函数 1 void fun(a& r) // 形参是类 A 的对象的引用变量 2 { 3 cout<<r.num<<endl; // 输出该引用变量的数据成员 num 4 } 函数的形参是类 A 的对象的引用变量, 函数 fun 的实参应该为 A 类的对象 5 fun(a1); // 此处,a1 为类 A 的对象 由于基类对象与派生类对象赋值兼容, 派生类的对象能自动转换类型, 在调用 fun 函数时可以用派生类 B 的对象 b1 作实参 : 6 fun(b1); 输出类 B 的对象 b1 的基类数据成员 num 的值 与前相同, 在 fun 函数中只能访问派生类中继承自基类的成员 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

62 赋值兼容及其限制赋值兼容及其限制 引用 派生类对象初始化基类的引用, 引用是派生类继承自基类部分成员的别名 1 class Base { 2 public: 3 Base() { cout<<"base"<<endl; } 4 void fun() { cout<<"base::fun()" <<endl; } 5 private: 6 int x; 7 }; 8 class Derive : public Base{ 9 public: 10 Derive() { cout<<"derive"<<endl; } 11 void fun() { cout<<"derive::fun()" <<endl; } 12 void show() { cout<<"derive::show()"<<endl; } 13 private: 14 int y; 15 }; 16 int main() { 17 Derive d; Base & b=d; b.fun(); // 18 b.show(); // 19 return 0; 20 } Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

63 赋值兼容及其限制赋值兼容及其限制 引用 派生类对象初始化基类的引用, 引用是派生类继承自基类部分成员的别名 1 class Base { 2 public: 3 Base() { cout<<"base"<<endl; } 4 void fun() { cout<<"base::fun()" <<endl; } 5 private: 6 int x; 7 }; 8 class Derive : public Base{ 9 public: 10 Derive() { cout<<"derive"<<endl; } 11 void fun() { cout<<"derive::fun()" <<endl; } 12 void show() { cout<<"derive::show()"<<endl; } 13 private: 14 int y; 15 }; 16 int main() { 17 Derive d; Base & b=d; b.fun(); // 正确 18 b.show(); // 错误 : 19 return 0; 20 } Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

64 赋值兼容及其限制赋值兼容及其限制 引用 派生类对象初始化基类的引用, 引用是派生类继承自基类部分成员的别名 1 class Base { 2 public: 3 Base() { cout<<"base"<<endl; } 4 void fun() { cout<<"base::fun()" <<endl; } 5 private: 6 int x; 7 }; 8 class Derive : public Base{ 9 public: 10 Derive() { cout<<"derive"<<endl; } 11 void fun() { cout<<"derive::fun()" <<endl; } 12 void show() { cout<<"derive::show()"<<endl; } 13 private: 14 int y; 15 }; 16 int main() { 17 Derive d; Base & b=d; b.fun(); // 正确 18 b.show(); // 错误 : 派生类对象可初始化基类引用, 但不能访问非继承自基类的成员 19 return 0; 20 } Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

65 赋值兼容及其限制赋值兼容及其限制 引用 派生类对象初始化基类的引用, 引用是派生类继承自基类部分成员的别名 1 class Base { 2 public: 3 Base() { cout<<"base"<<endl; } 4 void fun() { cout<<"base::fun()" <<endl; } 5 private: 6 int x; 7 }; 8 class Derive : public Base{ 9 public: 10 Derive() { cout<<"derive"<<endl; } 11 void fun() { cout<<"derive::fun()" <<endl; } 12 void show() { cout<<"derive::show()"<<endl; } 13 private: 14 int y; 15 }; 16 int main() { 17 Derive d; Base & b=d; b.fun(); // 正确 18 b.show(); // 错误 : 派生类对象可初始化基类引用, 但不能访问非继承自基类的成员如果删除错误之处 19 return 0;, 则运行结果为 : 20 } Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

66 赋值兼容及其限制赋值兼容及其限制 引用 派生类对象初始化基类的引用, 引用是派生类继承自基类部分成员的别名 1 class Base { 2 public: 3 Base() { cout<<"base"<<endl; } 4 void fun() { cout<<"base::fun()" <<endl; } 5 private: 6 int x; 7 }; 8 class Derive : public Base{ 9 public: 10 Derive() { cout<<"derive"<<endl; } 11 void fun() { cout<<"derive::fun()" <<endl; } 12 void show() { cout<<"derive::show()"<<endl; } 13 private: 14 int y; 15 }; 16 int main() { 17 Derive d; Base & b=d; b.fun(); // 正确 18 b.show(); // 错误 : 派生类对象可初始化基类引用, 但不能访问非继承自基类的成员 如果删除错误之处 19 return 0;, 则运行结果为 :Base 20 } Derive Base::fun() Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

67 赋值兼容及其限制赋值兼容及其限制 指针 派生类对象的地址可以赋给指向基类对象的指针变量, 即 : 指向基类对象的指针变量也可以指向派生类对象 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

68 赋值兼容及其限制赋值兼容及其限制 指针 派生类对象的地址可以赋给指向基类对象的指针变量, 即 : 指向基类对象的指针变量也可以指向派生类对象 普通方式 : 1 class Base 2 { 3 public: 4 void Demon() { cout << "This is Father Demon!" << endl; } 5 void Display (){ cout << "This is Father Display!" << endl; } 6 }; 7 class SubBase : public Base 8 { 9 public: 10 void Demon() { cout << "This is Derived Demon!" << endl; } 11 void Display() { cout << "This is Derived Display!" << endl; } 12 }; 13 int main() 14 { 15 Base * inst = new SubBase(); inst->demon(); inst->display(); 16 return 0; 17 } 运行结果 : Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

69 赋值兼容及其限制赋值兼容及其限制 指针 派生类对象的地址可以赋给指向基类对象的指针变量, 即 : 指向基类对象的指针变量也可以指向派生类对象 普通方式 : 1 class Base 2 { 3 public: 4 void Demon() { cout << "This is Father Demon!" << endl; } 5 void Display (){ cout << "This is Father Display!" << endl; } 6 }; 7 class SubBase : public Base 8 { 9 public: 10 void Demon() { cout << "This is Derived Demon!" << endl; } 11 void Display() { cout << "This is Derived Display!" << endl; } 12 }; 13 int main() 14 { 15 Base * inst = new SubBase(); inst->demon(); inst->display(); 16 return 0; 17 } 运行结果 : This is Father Demon! This is Father Display! Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

70 赋值兼容及其限制赋值兼容及其限制 指针 派生类对象的地址可以赋给指向基类对象的指针变量, 即 : 指向基类对象的指针变量也可以指向派生类对象 多态方式 : 1 class Base 2 { 3 public: 4 virtual void Demon() { cout << "This is Father Demon!" << endl; } 5 virtual void Display (){ cout << "This is Father Display!"<< endl; } 6 }; 7 class SubBase : public Base 8 { 9 public: 10 void Demon() { cout << "This is Derived Demon!" << endl; } 11 void Display() { cout << "This is Derived Display!" << endl; } 12 }; 13 int main() 14 { 15 Base * inst = new SubBase(); inst->demon(); inst->display(); 16 return 0; 17 } 运行结果 : Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

71 赋值兼容及其限制赋值兼容及其限制 指针 派生类对象的地址可以赋给指向基类对象的指针变量, 即 : 指向基类对象的指针变量也可以指向派生类对象 多态方式 : 1 class Base 2 { 3 public: 4 virtual void Demon() { cout << "This is Father Demon!" << endl; } 5 virtual void Display (){ cout << "This is Father Display!"<< endl; } 6 }; 7 class SubBase : public Base 8 { 9 public: 10 void Demon() { cout << "This is Derived Demon!" << endl; } 11 void Display() { cout << "This is Derived Display!" << endl; } 12 }; 13 int main() 14 { 15 Base * inst = new SubBase(); inst->demon(); inst->display(); 16 return 0; 17 } 运行结果 : This is Derived Demon! This is Derived Display! Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

72 赋值兼容及其限制赋值兼容及其限制 指针 派生类对象的地址可以赋给指向基类对象的指针变量, 即 : 指向基类对象的指针变量也可以指向派生类对象 多态方式 : 1 class Shape{ 2 public: 3 virtual double area() const = 0; 4 }; 5 class Square : public Shape { 6 double size; 7 public: 8 Square(double s) 9 { size = s; } 10 virtual double area() const 11 { return size * size; } 12 }; 13 class Circle : public Shape { 14 double R; 15 public: 16 Circle(double r) 17 { radius = r; } 18 virtual double area() const 19 { return *R*R; } 20 }; 21 int main() 22 { 23 Shape * ps[2]; // 基类指针数组 24 Square Squ(2.0); 25 Circle Cir(1.0); 26 ps[0] = &Squ; 27 ps[1] = &Cir; 28 for (int i = 0; i < 2; i++) 29 {cout<<ps[i]->area()<<"\n";} 30 return 0; 31 } 运行结果 : Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

73 赋值兼容及其限制赋值兼容及其限制 指针 派生类对象的地址可以赋给指向基类对象的指针变量, 即 : 指向基类对象的指针变量也可以指向派生类对象 多态方式 : 1 class Shape{ 2 public: 3 virtual double area() const = 0; 4 }; 5 class Square : public Shape { 6 double size; 7 public: 8 Square(double s) 9 { size = s; } 10 virtual double area() const 11 { return size * size; } 12 }; 13 class Circle : public Shape { 14 double R; 15 public: 16 Circle(double r) 17 { radius = r; } 18 virtual double area() const 19 { return *R*R; } 20 }; 21 int main() 22 { 23 Shape * ps[2]; // 基类指针数组 24 Square Squ(2.0); 25 Circle Cir(1.0); 26 ps[0] = &Squ; 27 ps[1] = &Cir; 28 for (int i = 0; i < 2; i++) 29 {cout<<ps[i]->area()<<"\n";} 30 return 0; 31 } 运行结果 : Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

74 赋值兼容及其限制赋值兼容及其限制 指针 派生类对象的地址可以赋给指向基类对象的指针变量, 即 : 指向基类对象的指针变量也可以指向派生类对象 动态联编 : 1 class Shape{ 2 public: 3 virtual double area() const = 0; 4 }; 5 class Square : public Shape { 6 double size; 7 public: 8 Square(double s) 9 { size = s; } 10 virtual double area() const 11 { return size * size; } 12 }; 13 class Circle : public Shape { 14 double R; 15 public: 16 Circle(double r) 17 { radius = r; } 18 virtual double area() const 19 { return *R*R; } 20 }; 21 int main() 22 { 23 Shape * ps[2]; // 基类指针数组 24 Square Squ(2.0); 25 Circle Cir(1.0); 26 ps[0] = &Squ; 27 ps[1] = &Cir; 28 for (int i = 0; i < 2; i++) 29 {cout<<ps[i]->area()<<"\n";} 30 return 0; 31 } 运行结果 : 基类指针指向派生类对象 这可以实现运行时的多态性 ( 也称为动态联编 ) Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

75 赋值兼容及其限制赋值兼容及其限制 指针 派生类对象的地址可以赋给指向基类对象的指针变量, 即 : 指向基类对象的指针变量也可以指向派生类对象 动态联编 : 1 class Shape{ 18 virtual double area() const 2 public: 19 { return *R*R; } 3 virtual double area() const 20 }; = 0; 21 int main() 4 }; 22 { 5 class Square : public Shape { 23 Shape * ps[2]; // 基类指针数组 6 double size; 24 Square Squ(2.0); 7 public: 25 Circle Cir(1.0); 8 Square(double s) 26 ps[0] = &Squ; 9 { size = s; } 27 ps[1] = &Cir; 10 virtual double area() const 28 for (int i = 0; i < 2; i++) 11 { return size * size; } 29 {cout<<ps[i]->area()<<"\n";} 12 }; 30 return 0; 13 class Circle : public Shape { 31 } 14 double R; 运行结果 : 15 public: 4 16 Circle(double r) 注意 :{ 使用基类指针或引用时 radius = r; }, 只允许访问从相应基类中继承来的成员, 基类指针指向派生类对象 这可以实现运行时的多态性不允许访问其他基类的成员或派生类新增加的成员 ( 也称为动态联编 ) Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

76 赋值兼容及其限制赋值兼容及其限制 例程 定义一个基类 Student, 再定义由 Student 类的公有派生出的类 Graduate 类 Student 设 num( 学号 ) name( 名字 ) 和 score( 成绩 )3 个数据和函数 display() 在 Graduate 类只增加一个数据成员 pay( 工资 ) 和成员函数 display() 用指向基类 Student 的指针变量访问派生类 Graduate 对象的数据 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

77 赋值兼容及其限制赋值兼容及其限制 例程 定义一个基类 Student, 再定义由 Student 类的公有派生出的类 Graduate 类 Student 设 num( 学号 ) name( 名字 ) 和 score( 成绩 )3 个数据和函数 display() 在 Graduate 类只增加一个数据成员 pay( 工资 ) 和成员函数 display() 用指向基类 Student 的指针变量访问派生类 Graduate 对象的数据 1 class Student { 2 public: 3 Student(int,string,float); 4 void display( ); 5 private: 6 int num; string name; float score; 7 }; 8 class Graduate : public Student{ 9 public: 10 Graduate(int,string,float, float); 11 void display( ); 12 private: 13 float payment; // 工资 14 }; Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

78 赋值兼容及其限制赋值兼容及其限制 例程 定义一个基类 Student, 再定义由 Student 类的公有派生出的类 Graduate 类 Student 设 num( 学号 ) name( 名字 ) 和 score( 成绩 )3 个数据和函数 display() 在 Graduate 类只增加一个数据成员 pay( 工资 ) 和成员函数 display() 用指向基类 Student 的指针变量访问派生类 Graduate 对象的数据 1 class Student { 2 public: 3 Student(int,string,float); 4 void display( ); 5 private: 6 int num; string name; float score; 7 }; 8 class Graduate : public Student{ 9 public: 10 Graduate(int,string,float, float); 11 void display( ); 12 private: 13 float payment; // 工资 14 }; 15 int main() { 16 Student stud1(1001, "XiaoWu", 99.5); 17 Graduate grad1(2001, "XiaoLi", 95.5, 1200); 18 Student *pt = &stud1; // 定义指向 Student 类对象的指针并指向 stud1 19 pt->display( );...;...; 20 } Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

79 赋值兼容及其限制赋值兼容及其限制 例程 定义一个基类 Student, 再定义由 Student 类的公有派生出的类 Graduate 1 #include <iostream> 2 #include <string> 3 using namespace std; 4 class Student // 声明 Student 类 5 { 6 public: 7 Student(int, string,float); // 声明构造函数 8 void display( ); // 声明输出函数 9 private: 10 int num; 11 string name; 12 float score; 13 }; 14 Student::Student(int n, string nam,float s) // 定义构造函数 15 { 16 num=n; 17 name=nam; 18 score=s; 19 } 20 void Student::display( ) // 定义输出函数 21 { Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

80 赋值兼容及其限制赋值兼容及其限制 例程 22 cout<<endl<<"num:"<<num<<endl; 23 cout<<"name:"<<name<<endl; 24 cout<<"score:"<<score<<endl; 25 } 26 class Graduate:public Student // 声明公用派生类 Graduate 27 { 28 public: 29 Graduate(int, string,float,float); // 声明构造函数 30 void display( ); // 声明输出函数 31 private: 32 float pay; // 工资 33 }; 34 // 定义构造函数 35 Graduate::Graduate(int n, string nam,float s,float p):student(n,nam,s), pay(p) 36 { } 37 void Graduate::display() // 定义输出函数 38 { 39 Student::display(); // 调用 Student 类的 display 函数 40 cout<<"pay="<<pay<<endl; 41 } 42 int main() Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

81 赋值兼容及其限制赋值兼容及其限制 例程 43 { 44 Student stud1(1001, "XiaoWu", 99.5); //Student 的对象 45 Graduate grad1(2001, "XiaoLi", 95.5, 1200); //Graduate 的对象 46 Student *pt=&stud1; // 指向 Student 类对象的指针并指向 stud1 47 pt->display( ); // 调用 stud1.display 函数 48 pt=&grad1; // 指针指向 grad1 49 pt->display( ); // 调用 grad1.display 函数 50 } Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

82 赋值兼容及其限制赋值兼容及其限制 例程 43 { 44 Student stud1(1001, "XiaoWu", 99.5); //Student 的对象 45 Graduate grad1(2001, "XiaoLi", 95.5, 1200); //Graduate 的对象 46 Student *pt=&stud1; // 指向 Student 类对象的指针并指向 stud1 47 pt->display( ); // 调用 stud1.display 函数 48 pt=&grad1; // 指针指向 grad1 49 pt->display( ); // 调用 grad1.display 函数 50 } 程序输出结果为 : num:1001 name:li score:99.5 num:2001 name:wang score:95.5 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

83 赋值兼容及其限制赋值兼容及其限制 例程 43 { 44 Student stud1(1001, "XiaoWu", 99.5); //Student 的对象 45 Graduate grad1(2001, "XiaoLi", 95.5, 1200); //Graduate 的对象 46 Student *pt=&stud1; // 指向 Student 类对象的指针并指向 stud1 47 pt->display( ); // 调用 stud1.display 函数 48 pt=&grad1; // 指针指向 grad1 49 pt->display( ); // 调用 grad1.display 函数 50 } 程序输出结果为 : num:1001 name:li score:99.5 num:2001 name:wang score:95.5 由此程序可知 : 用指向基类对象的指针变量指向派生类对象是完全合法且安全的, 不会出现编译上的错误 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

84 赋值兼容及其限制赋值兼容及其限制 例程 43 { 44 Student stud1(1001, "XiaoWu", 99.5); //Student 的对象 45 Graduate grad1(2001, "XiaoLi", 95.5, 1200); //Graduate 的对象 46 Student *pt=&stud1; // 指向 Student 类对象的指针并指向 stud1 47 pt->display( ); // 调用 stud1.display 函数 48 pt=&grad1; // 指针指向 grad1 49 pt->display( ); // 调用 grad1.display 函数 50 } 程序输出结果为 : num:1001 name:li score:99.5 num:2001 name:wang score:95.5 由此程序可知 : 用指向基类对象的指针变量指向派生类对象是完全合法且安全的, 不会出现编译上的错误 当希望通过使用基类指针调用派生类对象的成员时, 就要使用虚函数和多态性 ( 这些特性将在后面的章节中介绍 ) Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

85 提纲 总结与思考 1 访问冲突 2 支配规则 3 虚基类与构造函数 4 赋值兼容及其限制 5 总结与思考 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

86 总结与思考 总结与思考 访问冲突与二义性 什么是多重继承中的访问冲突 ( 二义性问题 )? 发生二义性问题有哪两种情况? 如何解决访问冲突? Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

87 总结与思考 总结与思考 访问冲突与二义性什么是多重继承中的访问冲突 ( 二义性问题 )? 发生二义性问题有哪两种情况? 如何解决访问冲突? 支配规则什么是支配规则? 支配规则在什么情况下起作用? 什么是同名隐藏? Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

88 总结与思考 总结与思考 访问冲突与二义性 什么是多重继承中的访问冲突 ( 二义性问题 )? 发生二义性问题有哪两种情况? 如何解决访问冲突? 支配规则 什么是支配规则? 支配规则在什么情况下起作用? 什么是同名隐藏? 虚基类及其特点 当在多条继承路径上有一个公共的基类, 在这些路径的某几条汇合处, 这个公共的基类就会产生多个实例 ( 或副本 ), 若只想保存这个基类的一个实例, 可以将这个公共基类说明为虚基类 虚基类构造函数的参数必须由最新派生出来的类负责初始化 ( 即使不是直接继承 ); 虚基类的构造函数先于非虚基类的构造函数执行 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

89 总结与思考 总结与思考 访问冲突与二义性 什么是多重继承中的访问冲突 ( 二义性问题 )? 发生二义性问题有哪两种情况? 如何解决访问冲突? 支配规则 什么是支配规则? 支配规则在什么情况下起作用? 什么是同名隐藏? 虚基类及其特点 当在多条继承路径上有一个公共的基类, 在这些路径的某几条汇合处, 这个公共的基类就会产生多个实例 ( 或副本 ), 若只想保存这个基类的一个实例, 可以将这个公共基类说明为虚基类 虚基类构造函数的参数必须由最新派生出来的类负责初始化 ( 即使不是直 接继承 ); 虚基类的构造函数先于非虚基类的构造函数执行 class Ancestor { }; class Father : virtual public Ancestor{ }; class Mother : virtual public Ancestor{ }; class Child : public Father, public Mother{ }; 在类 Child 的对象中, 仅有类 Ancestor 的一个对象数据 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

90 总结与思考 总结与思考 赋值兼容及其限制 可将公有派生类的对象赋值给基类的对象, 就像把派生类对象新定义的成员切割 / 切除后赋给基类的对象 ; Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

91 总结与思考 总结与思考 赋值兼容及其限制 可将公有派生类的对象赋值给基类的对象, 就像把派生类对象新定义的成员切割 / 切除后赋给基类的对象 ; 不允许将基类的对象赋值给派生类的对象 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

92 总结与思考 总结与思考 赋值兼容及其限制 可将公有派生类的对象赋值给基类的对象, 就像把派生类对象新定义的成员切割 / 切除后赋给基类的对象 ; 不允许将基类的对象赋值给派生类的对象 赋值兼容及其限制可归结为 : 1 可以将派生类对象赋值给基类对象 : 系统将派生类对象中从基类继承来的成员赋给基类对象的成员 2 不能将基类对象赋值给派生类对象 : 基类中的成员变量必然少于派生类, 派生类新定义的成员变量不可无值可赋 3 私有或保护派生类的对象不能够赋值给基类的对象 : 派生类不能够突破关键词 private 或 protected 所限定的访问权限 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

93 总结与思考 总结与思考 赋值兼容及其限制 可将公有派生类的对象赋值给基类的对象, 就像把派生类对象新定义的成员切割 / 切除后赋给基类的对象 ; 不允许将基类的对象赋值给派生类的对象 赋值兼容及其限制可归结为 : 1 可以将派生类对象赋值给基类对象 : 系统将派生类对象中从基类继承来的成员赋给基类对象的成员 2 不能将基类对象赋值给派生类对象 : 基类中的成员变量必然少于派生类, 派生类新定义的成员变量不可无值可赋 3 私有或保护派生类的对象不能够赋值给基类的对象 : 派生类不能够突破关键词 private 或 protected 所限定的访问权限 4 可将派生类对象的地址赋给基类类型的指针变量, 例如 Base *ptr = &der_obj 5 派生类的对象可初始化基类类型的引用, 例如 Base &ref = der_obj Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

94 总结与思考 总结与思考 赋值兼容及其限制 可将公有派生类的对象赋值给基类的对象, 就像把派生类对象新定义的成员切割 / 切除后赋给基类的对象 ; 不允许将基类的对象赋值给派生类的对象 赋值兼容及其限制可归结为 : 1 可以将派生类对象赋值给基类对象 : 系统将派生类对象中从基类继承来的成员赋给基类对象的成员 2 不能将基类对象赋值给派生类对象 : 基类中的成员变量必然少于派生类, 派生类新定义的成员变量不可无值可赋 3 私有或保护派生类的对象不能够赋值给基类的对象 : 派生类不能够突破关键词 private 或 protected 所限定的访问权限 4 可将派生类对象的地址赋给基类类型的指针变量, 例如 Base *ptr = &der_obj 5 派生类的对象可初始化基类类型的引用, 例如 Base &ref = der_obj Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

95 总结与思考 总结与思考 赋值兼容及其限制 可将公有派生类的对象赋值给基类的对象, 就像把派生类对象新定义的成员切割 / 切除后赋给基类的对象 ; 不允许将基类的对象赋值给派生类的对象 赋值兼容及其限制可归结为 : 1 可以将派生类对象赋值给基类对象 : 系统将派生类对象中从基类继承来的成员赋给基类对象的成员 2 不能将基类对象赋值给派生类对象 : 基类中的成员变量必然少于派生类, 派生类新定义的成员变量不可无值可赋 3 私有或保护派生类的对象不能够赋值给基类的对象 : 派生类不能够突破关键词 private 或 protected 所限定的访问权限 4 可将派生类对象的地址赋给基类类型的指针变量, 例如 Base *ptr = &der_obj 5 派生类的对象可初始化基类类型的引用, 例如 Base &ref = der_obj Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

96 总结与思考 总结与思考 赋值兼容及其限制 可将公有派生类的对象赋值给基类的对象, 就像把派生类对象新定义的成员切割 / 切除后赋给基类的对象 ; 不允许将基类的对象赋值给派生类的对象 赋值兼容及其限制可归结为 : 1 可以将派生类对象赋值给基类对象 : 系统将派生类对象中从基类继承来的成员赋给基类对象的成员 2 不能将基类对象赋值给派生类对象 : 基类中的成员变量必然少于派生类, 派生类新定义的成员变量不可无值可赋 3 私有或保护派生类的对象不能够赋值给基类的对象 : 派生类不能够突破关键词 private 或 protected 所限定的访问权限 4 可将派生类对象的地址赋给基类类型的指针变量, 例如 Base *ptr = &der_obj 5 派生类的对象可初始化基类类型的引用, 例如 Base &ref = der_obj Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

97 总结与思考 总结与思考 赋值兼容及其限制 可将公有派生类的对象赋值给基类的对象, 就像把派生类对象新定义的成员切割 / 切除后赋给基类的对象 ; 不允许将基类的对象赋值给派生类的对象 赋值兼容及其限制可归结为 : 1 可以将派生类对象赋值给基类对象 : 系统将派生类对象中从基类继承来的成员赋给基类对象的成员 2 不能将基类对象赋值给派生类对象 : 基类中的成员变量必然少于派生类, 派生类新定义的成员变量不可无值可赋 3 私有或保护派生类的对象不能够赋值给基类的对象 : 派生类不能够突破关键词 private 或 protected 所限定的访问权限 4 可将派生类对象的地址赋给基类类型的指针变量, 例如 Base *ptr = &der_obj 5 派生类的对象可初始化基类类型的引用, 例如 Base &ref = der_obj Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

98 总结与思考 总结与思考 赋值兼容及其限制 可将公有派生类的对象赋值给基类的对象, 就像把派生类对象新定义的成员切割 / 切除后赋给基类的对象 ; 不允许将基类的对象赋值给派生类的对象 赋值兼容及其限制可归结为 : 1 可以将派生类对象赋值给基类对象 : 系统将派生类对象中从基类继承来的成员赋给基类对象的成员 2 不能将基类对象赋值给派生类对象 : 基类中的成员变量必然少于派生类, 派生类新定义的成员变量不可无值可赋 3 私有或保护派生类的对象不能够赋值给基类的对象 : 派生类不能够突破关键词 private 或 protected 所限定的访问权限 4 可将派生类对象的地址赋给基类类型的指针变量, 例如 Base *ptr = &der_obj 5 派生类的对象可初始化基类类型的引用, 例如 Base &ref = der_obj 在使用基类类型的指针变量或引用时 : 只允许访问从相应基类中继承来的成员, 不允许访问其他基类的成员或派生类新增加的成员 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

99 总结与思考 总结与思考 赋值兼容及其限制 可将公有派生类的对象赋值给基类的对象, 就像把派生类对象新定义的成员切割 / 切除后赋给基类的对象 ; 不允许将基类的对象赋值给派生类的对象 赋值兼容及其限制可归结为 : 1 可以将派生类对象赋值给基类对象 : 系统将派生类对象中从基类继承来的成员赋给基类对象的成员 2 不能将基类对象赋值给派生类对象 : 基类中的成员变量必然少于派生类, 派生类新定义的成员变量不可无值可赋 3 私有或保护派生类的对象不能够赋值给基类的对象 : 派生类不能够突破关键词 private 或 protected 所限定的访问权限 4 可将派生类对象的地址赋给基类类型的指针变量, 例如 Base *ptr = &der_obj 5 派生类的对象可初始化基类类型的引用, 例如 Base &ref = der_obj 在使用基类类型的指针变量或引用时 : 只允许访问从相应基类中继承来的成员, 不允许访问其他基类的成员或派生类新增加的成员 请思考原因 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38

100 总结与思考 作业 总结与思考 Dongke Sun (Southeast University) C++ Programming and Algorithms April 12, / 38