第七讲继承与多态

Size: px

Start display at page:

Download "第七讲继承与多态"

忧瑛吴
7 years ago
Views:

1 第七章继承与派生 1

2 本章主要内容的继承成员的访问控制单继承与多继承派生的构造析构函数成员的标识与访问深度探索 2

3 的继承与派生的继承与派生保持已有的特性而构造新的过程称为继承在已有的基础上新增自己的特性而产生新的过程称为派生被继承的已有称为基 ( 或父 ) 派生出的新称为派生 ( 或子 ) 3

4 的继承与派生继承与派生问题举例交通工具汽车小汽车卡车旅行车工具车轿车面包车 4

5 的继承与派生继承与派生问题举例猴子动物猫科鸟狮子虎猎豹 5

6 的继承与派生继承与派生问题举例几何形状圆矩形 6

7 的继承与派生继承与派生问题举例兼职技术人员雇员管理人员销售人员销售经理 7

8 的继承与派生的层次结构由上到下, 是一个具体化特殊化的过程由下到上, 是一个抽象化的过程 8

9 的继承与派生继承与派生的目的继承的目的 : 实现代码重用派生的目的 : 当新的问题出现, 原有程序无法解决 ( 或不能完全解决 ) 时, 需要对原有程序进行改造, 实现代码扩充 9

10 的继承与派生派生新的过程吸收基成员基的全部数据成员和除了构造析构函数外的全部函数成员改造基成员基成员的访问控制对基数据或函数成员的隐藏添加新的成员一般成员的添加构造函数和析构函数 10

11 的继承与派生派生的声明 class 派生名 : 继承方式基名 { 派生成员声明 ; 11

12 成员的访问控制继承方式不同继承方式的影响主要体现在 : 派生成员对基成员的访问权限通过派生对象对基成员的访问权限三种继承方式公有继承私有继承, 默认保护继承 12

13 成员的访问控制公有继承 (public) 基的 public 和 protected 成员的访问属性在派生中保持不变, 但基的 private 成员不可直接访问派生中的成员函数可以直接访问基中的 public 和 protected 成员, 但不能直接访问基的 private 成员通过派生的对象只能访问基的 public 成员 13

14 成员的访问控制例 7-1 公有继承举例 class Point { // 基 Point 的定义 public: // 公有函数成员 void initpoint(float x = 0, float y = 0) { this->x = x; this->y = y;} void move(float offx, float offy) { x += offx; y += offy; } float getx() const { return x; } float gety() const { return y; } private: // 私有数据成员 float x, y; 14

void move(float offx, float offy) { x += offx; y += offy; } float getx() const

15 class Rectangle: public Point { // 派生定义部分 public: // 新增公有函数成员 void initrectangle(float x, float y, float w, float h) { initpoint(x, y); // 调用基公有成员函数 this->w = w; this->h = h; } float geth() const { return h; } float getw() const { return w; } private: // 新增私有数据成员 float w, h; 15

调用基公有成员函数 this->w = w; this->h = h; } float geth() const { return h;

16 #include <iostream> #include <cmath> using namespace std; int main() { Rectangle rect; // 定义 Rectangle 的对象 // 设置矩形的数据 rect.initrectangle(2, 3, 20, 10); rect.move(3,2); // 移动矩形位置 cout << "The data of rect(x,y,w,h): " << endl; // 输出矩形的特征参数 cout << rect.getx() <<", " << rect.gety() << ", " << rect.getw() << ", " << rect.geth() << endl; return 0; } 16

move(3,2); // 移动矩形位置 cout << "The data of rect(x,y,w,h): " << endl; // 输出矩形的特征参

17 成员的访问控制私有继承 (private) 基的 public 和 protected 成员都以 private 身份出现在派生中, 但基的 private 成员不可直接访问派生中的成员函数可以直接访问基中的 public 和 protected 成员, 但不能直接访问基的 private 成员通过派生的对象不能直接访问基中的任何成员 17

18 成员的访问控制例 7-2 私有继承举例 class Rectangle: private Point { // 派生定义部分 public:// 新增公有函数成员 void initrectangle(float x, float y, float w, float h) { initpoint(x, y); // 调用基公有成员函数 this->w = w; this->h = h; } void move(float offx, float offy) { Point::move(offX, offy); } float getx() const { return Point::getX(); } float gety() const { return Point::getY(); } float geth() const { return h; } float getw() const { return w; } private: // 新增私有数据成员 float w, h; 18

move(float offx, float offy) { Point::move(offX, offy); } float getx() const { return Point::getX(); } float gety() const

19 #include <iostream> #include <cmath> using namespace std; int main() { Rectangle rect; // 定义 Rectangle 的对象 rect.initrectangle(2, 3, 20, 10); // 设置矩形的数据 rect.move(3,2); // 移动矩形位置 cout << "The data of rect(x,y,w,h): " << endl; cout << rect.getx() <<", " // 输出矩形的特征参数 << rect.gety() << ", " << rect.getw() << ", " << rect.geth() << endl; return 0; } 19

move(3,2); // 移动矩形位置 cout << "The data of rect(x,y,w,h): " << endl; cout << rect.

20 成员的访问控制保护继承 (protected) 基的 public 和 protected 成员都以 protected 身份出现在派生中, 但基的 private 成员不可直接访问派生中的成员函数可以直接访问基中的 public 和 protected 成员, 但不能直接访问基的 private 成员通过派生的对象不能直接访问基中的任何成员 20

21 成员的访问控制 protected 成员的特点与作用对建立其所在对象的模块来说, 它与 private 成员的性质相同对于其派生来说, 它与 public 成员的性质相同既实现了数据隐藏, 又方便继承, 实现代码重用 21

22 成员的访问控制例 protected 成员举例 class A { protected: int x; int main() { } A a; a.x = 5; // 错误 22

23 class A { protected: int x; class B: public A{ public: void function(); void B:function() { x = 5; // 正确 } 23

24 型兼容规则型兼容一个公有派生的对象在使用上可以被当作基的对象, 反之则禁止具体表现在 : 派生的对象可以隐含转换为基对象派生的对象可以初始化基的引用派生的指针可以隐含转换为基的指针通过基对象名指针只能使用从基继承的成员 24

25 例 7-3 型兼容规则举例型兼容 //7_3.cpp #include <iostream> using namespace std; class Base1 { // 基 Base1 定义 public: void display() const { cout << "Base1::display()" << endl; } 25

26 class Base2: public Base1 { // 公有派生 Base2 定义 public: void display() const { cout << "Base2::display()" << endl; } class Derived: public Base2 { // 公有派生 Derived 定义 public: void display() const { cout << "Derived::display()" << endl; } void fun(base1 *ptr) { // 参数为指向基对象的指针 ptr->display(); //" 对象指针 -> 成员名 " } 26

27 int main() { // 主函数 Base1 base1; // 声明 Base1 对象 Base2 base2; // 声明 Base2 对象 Derived derived; // 声明 Derived 对象 // 用 Base1 对象的指针调用 fun 函数 fun(&base1); // 用 Base2 对象的指针调用 fun 函数 fun(&base2); // 用 Derived 对象的指针调用 fun 函数 fun(&derived); } return 0; 运行结果 : Base1::display() Base1 ::display() Base1 ::display() 27

28 单继承与多继承基与派生的对应关系单继承派生只从一个基派生多继承派生从多个基派生多重派生由一个基派生出多个不同的派生多层派生派生又作为基, 继续派生新的 28

29 单继承与多继承多继承时派生的声明 class 派生名 : 继承方式 1 基名 1, 继承方式 2 基名 2, { 派生成员声明 ; 注意 : 每一个继承方式, 只用于限制对紧随其后之基的继承 29

30 单继承与多继承多继承举例 class A { public: void seta(int); void showa() const; private: int a; class B { public: void setb(int); void showb() const; private: int b; class C : public A, private B { public: void setc(int, int, int); void showc() const; private const: int c; 30

31 void A::setA(int x) { } a=x; void B::setB(int x) { } b=x; void C::setC(int x, int y, int z) { } // 派生成员直接访问基的 // 公有成员 seta(x); setb(y); c = z; // 其他函数实现略 int main() { C obj; obj.seta(5); obj.showa(); obj.setc(6,7,9); obj.showc(); // obj.setb(6); 错误 // obj.showb(); 错误 return 0; } 31

32 派生的构造析构函数继承时的构造函数基的构造函数不被继承, 派生中需要声明自己的构造函数定义构造函数时, 只需要对本中新增成员进行初始化, 对继承来的基成员的初始化, 自动调用基构造函数完成派生的构造函数需要给基的构造函数传递参数 32

33 派生的构造析构函数单一继承时的构造函数派生名 :: 派生名 ( 参数表 ) : 基名 ( 基初始化参数表 ), 成员对象名 1( 成员对象 1 初始化参数表 ),, 成员对象名 m( 成员对象 m 初始化参数表 ) { 其他初始化操作 ; 33

34 派生的构造析构函数单一继承时的构造函数举例 #include<iostream> using namecpace std; class B { public: B(); B(int i); ~B(); void print() const; private: int b; 34

35 B::B() { b=0; cout << "B's default constructor called." << endl; } B::B(int i) { b=i; cout << "B's constructor called." << endl; } B::~B() { cout << "B's destructor called." << endl; } void B::print() const { cout << b << endl; } 35

36 class C: public B { public: C(); C(int i, int j); ~C(); void print() const; private: int c; 36

37 C::C() { c = 0; cout << "C's default constructor called." << endl; } C::C(int i,int j): B(i) { c = j; cout << "C's constructor called." << endl; } C::~C() { cout << "C's destructor called." << endl; } void C::print() const { B::print(); cout << c << endl; } int main() { C obj(5, 6); obj.print(); return 0; } 37

38 派生的构造析构函数多继承时的构造函数派生名 :: 派生名 ( 参数表 ) : 基名 1( 基 1 初始化参数表 ), 基名 2( 基 2 初始化参数表 ),... 基名 n( 基 n 初始化参数表 ), 成员对象名 1( 成员对象 1 初始化参数表 ),, 成员对象名 m( 成员对象 m 初始化参数表 ) { 其他初始化操作 ; 38

39 派生的构造析构函数派生与基的构造函数当基中声明有缺省构造函数或未声明构造函数时, 派生构造函数可以不向基构造函数传递参数, 也可以不声明构造派生的对象时, 基的缺省构造函数将被调用当需要执行基中带形参的构造函数来初始化基数据时, 派生构造函数应在初始化列表中为基构造函数提供参数 39

40 派生的构造析构函数构造函数的执行顺序 1. 调用基构造函数, 调用顺序按照它们被继承时声明的顺序 ( 从左向右 ) 2. 对派生新增的成员对象进行初始化, 初始化顺序按照它们在中声明的顺序 3. 执行派生的构造函数体中的内容 41

41 派生的构造析构函数拷贝构造函数若建立派生对象时没有编写拷贝构造函数, 编译器会生成一个隐含的拷贝构造函数, 该函数先调用基的拷贝构造函数, 再为派生新增的成员对象执行拷贝若编写派生的拷贝构造函数, 一般需要为基相应的拷贝构造函数传递参数例如 : C::C(C &c1): B(c1) { } 42

42 派生的构造析构函数例 7-4 派生构造函数举例 //7_4.cpp #include <iostream> using namespace std; class Base1 { // 基 Base1, 构造函数有参数 public: Base1(int i) { cout << "Constructing Base1 " << i << endl; } class Base2 { // 基 Base2, 构造函数有参数 public: Base2(int j) { cout << "Constructing Base2 " << j << endl; } class Base3 { // 基 Base3, 构造函数无参数 public: Base3() { cout << "Constructing Base3 *" << endl; } 43

43 class Derived: public Base2, public Base1, public Base3 { // 派生新 Derived, 注意基名的顺序 public: // 派生的公有成员 Derived(int a, int b, int c, int d): Base1(a), member2(d), member1(c), Base2(b) { } // 注意基名的个数与顺序,// 注意成员对象名的个数与顺序 private: Base1 member1; Base2 member2; Base3 member3; // 派生的私有成员对象 int main() { Derived obj(1, 2, 3, 4); return 0; } 运行结果 : constructing Base2 2 constructing Base1 1 constructing Base3 * constructing Base1 3 constructing Base2 4 constructing Base3 * 44

44 派生的构造析构函数继承时的析构函数析构函数也不被继承, 派生自行声明声明方法与一般 ( 无继承关系时 ) 的析构函数相同不需要显式地调用基的析构函数, 系统会自动隐式调用析构函数的调用次序与构造函数相反 45

45 派生的构造析构函数例 7-5 派生析构函数举例 //7_5.cpp #include <iostream> using namespace std; class Base1 { // 基 Base1, 构造函数有参数 public: Base1(int i) { cout << "Constructing Base1 " << i << endl; } ~Base1() { cout << "Destructing Base1" << endl; } class Base2 { // 基 Base2, 构造函数有参数 public: Base2(int j) { cout << "Constructing Base2 " << j << endl; } ~Base2() { cout << "Destructing Base2" << endl; } class Base3 { // 基 Base3, 构造函数无参数 public: Base3() { cout << "Constructing Base3 *" << endl; } ~Base3() { cout << "Destructing Base3" << endl; } 46

46 class Derived: public Base2, public Base1, public Base3 { // 派生新 Derived, 注意基名的顺序 public: // 派生的公有成员 Derived(int a, int b, int c, int d): Base1(a), member2(d), member1(c), Base2(b) { } // 注意基名的个数与顺序, 注意成员对象名的个数与顺序 private: // 派生的私有成员对象 Base1 member1; Base2 member2; Base3 member3; int main() { Derived obj(1, 2, 3, 4); return 0; } 47

47 例 7-5 运行结果 Constructing Base2 2 Constructing Base1 1 Constructing Base3 * Constructing Base1 3 Constructing Base2 4 Constructing Base3 * Destructing Base3 Destructing Base2 Destructing Base1 Destructing Base3 Destructing Base1 Destructing Base2 48

48 派生成员的标识与访问派生成员的访问派生成员的访问属性不可访问的成员私有成员保护成员公有成员两个问题唯一标识问题可见性问题 49

49 派生成员的标识与访问同名隐藏规则当派生与基中有相同成员时 : 若未强行指明, 则通过派生对象使用的是派生中的同名成员如要通过派生对象访问基中被隐藏的同名成员, 应使用作用域分辨符和基名来限定 50

50 派生成员的标识与访问例 7-6 多继承同名隐藏举例 (1) //7_6.cpp #include <iostream> using namespace std; class Base1 { // 定义基 Base1 public: int var; void fun() { cout << "Member of Base1" << endl; } class Base2 { // 定义基 Base2 public: int var; void fun() { cout << "Member of Base2" << endl; } class Derived: public Base1, public Base2 { // 定义派生 Derived public: int var; // 同名数据成员 void fun() { cout << "Member of Derived" << endl; } // 同名函数成员 51

51 int main() { Derived d; Derived *p = &d; d.var = 1; // 对象名. 成员名标识 d.fun(); // 访问 Derived 成员 d.base1::var = 2; // 作用域分辨符标识 d.base1::fun(); // 访问 Base1 基成员 p->base2::var = 3; p->base2::fun(); // 作用域分辨符标识 // 访问 Base2 基成员 } return 0; 52

52 派生成员的标识与访问二义性问题在多继承时, 基与派生之间, 或基之间出现同名成员时, 将出现访问时的二义性 ( 不确定性 ) 采用虚函数 ( 参见第 8 章 ) 或同名隐藏规则来解决当派生从多个基派生, 而这些基又从同一个基派生, 则在访问此共同基中的成员时, 将产生二义性采用虚基来解决 53

53 派生成员的标识与访问二义性问题举例 ( 一 ) class A { public: void f(); class B { public: void f(); void g() class C: public A, piblic B { public: void g(); void h(); 如果定义 :C c1; 则 c1.f() 具有二义性而 c1.g() 无二义性 ( 同名隐藏 ) 54

54 派生成员的标识与访问二义性的解决方法解决方法一 : 用基名来限定 c1.a::f() 或 c1.b::f() 解决方法二 : 同名隐藏在 C 中声明一个同名成员函数 f(),f() 再根据需要调用 A::f() 或 B::f() 55

55 派生成员的标识与访问二义性问题举例 ( 二 ) class B { public: int b; } class B1: public B { private: int b1; class B2: public B { private: int b2; class C : public B1,public B2 { public: 有二义性 : int f(); C c; private: c.b int d; c.b::b } 无二义性 : c.b1::b c.b2::b 56

56 虚基虚基的引入用于有共同基的场合声明以 virtual 修饰说明基例 :class B1:virtual public B 作用主要用来解决多继承时可能发生的对同一基继承多次而产生的二义性问题. 为最远派生提供唯一的基成员, 而不重复产生多次拷贝注意 : 在第一级继承时就要将共同基设计为虚基 57

57 虚基虚基举例 class B { public: int b; class B1: virtual public B { public: int b1; class B2: virtual public B { public: int b2; class C: public B1, public B2 { public: float d; 下面的访问是正确的 : C cobj; cobj.b; 58

58 虚例 7-8 虚基举例基 + var0 : int <<virtual>> Base0 + fun0() : void Derived Base1 + var1 : int Base2 + var2 : int Base0::var0:int Base1::var1:int Base2::var2:int var :int Base0::fun0():void fun():void Derived + var : int + fun() : void 59

59 //7_8.cpp #include <iostream> using namespace std; class Base0 { // 定义基 Base0 public: int var0; void fun0() { cout << "Member of Base0" << endl; } class Base1: virtual public Base0 { // 定义派生 Base1 public: // 新增外部接口 int var1; class Base2: virtual public Base0 { // 定义派生 Base2 public: // 新增外部接口 int var2; 60

60 class Derived: public Base1, public Base2 { // 定义派生 Derived public: // 新增外部接口 int var; void fun() { cout << "Member of Derived" << endl; } int main() { // 程序主函数 Derived d; // 定义 Derived 对象 d d.var0 = 2; // 直接访问虚基的数据成员 d.fun0(); // 直接访问虚基的函数成员 return 0; } 61

61 虚虚基及其派生构造函数基建立对象时所指定的称为最远派生虚基的成员是由最远派生的构造函数通过调用虚基的构造函数进行初始化的在整个继承结构中, 直接或间接继承虚基的所有派生, 都必须在构造函数的成员初始化表中给出对虚基的构造函数的调用如果未列出, 则表示调用该虚基的默认构造函数在建立对象时, 只有最远派生的构造函数调用虚基的构造函数, 该派生的其他基对虚基构造函数的调用被忽略 62

62 虚基有虚基时的构造函数举例 #include <iostream> using namespace std; class Base0 { // 定义基 Base0 public: Base0(int var) : var0(var) { } int var0; void fun0() { cout << "Member of Base0" << endl; } class Base1: virtual public Base0 { // 定义派生 Base1 public: // 新增外部接口 Base1(int var) : Base0(var) { } int var1; class Base2: virtual public Base0 { // 定义派生 Base2 public: // 新增外部接口 Base2(int var) : Base0(var) { } int var2; 63

63 class Derived: public Base1, public Base2 { // 定义派生 Derived public: // 新增外部接口 Derived(int var) : Base0(var), Base1(var), Base2(var) { } int var; void fun() { cout << "Member of Derived" << endl; } int main() { // 程序主函数 Derived d(1); // 定义 Derived 对象 d d.var0 = 2; // 直接访问虚基的数据成员 d.fun0(); // 直接访问虚基的函数成员 return 0; } 64

64 组合与继承深度探索组合与继承 : 通过已有来构造新的两种基本方式组合 :B 中存在一个 A 型的内嵌对象有一个 (has-a) 关系 : 表明每个 B 型对象有一个 A 型对象 A 型对象与 B 型对象是部分与整体关系 B 型的接口不会直接作为 A 型的接口 65

65 has-a 举例深度探索 class Engine { // 发动机 public: void work(); // 发动机运转 class Wheel { // 轮子 public: void roll(); // 轮子转动 class Automobile { // 汽车 public: void move(); // 汽车移动 private: Engine engine; // 汽车引擎 Wheel wheels[4];//4 个车轮意义一辆汽车有一个发动机一辆汽车有四个轮子接口作为整体的汽车不再具备发动机的运转功能, 和轮子的转动功能, 但通过将这些功能的整合, 具有了自己的功能移动 66

66 公有继承的意义深度探索公有继承 :A 是 B 的公有基是一个 (is-a) 关系 : 表明每个 B 型对象是一个 A 型对象 A 型对象与 B 型对象是一般与特殊关系回顾的兼容性原则 : 在需要基对象的任何地方, 都可以使用公有派生的对象来替代 B 型对象包括 A 型的全部接口 67

67 is-a 举例深度探索 class Truck: public Automobile{ // 卡车 public: void load( ); // 装货 void dump( ); // 卸货 private: class Pumper: public Automobile { // 消防车 public: void water(); // 喷水 private: 意义卡车是汽车消防车是汽车接口卡车和消防车具有汽车的通用功能 ( 移动 ) 它们还各自具有自己的功能 ( 卡车 : 装货卸货 ; 消防车 : 喷水 ) 68

68 派生对象的内存布局深度探索派生对象的内存布局因编译器而异内存布局应使型兼容规则便于实现一个基指针, 无论其指向基对象, 还是派生对象, 通过它来访问一个基中定义的数据成员, 都可以用相同的步骤不同情况下的内存布局单继承 : 基数据在前, 派生新增数据在后多继承 : 各基数据按顺序在前, 派生新增数据在后虚继承 : 需要增加指针, 间接访问虚基数据 69

69 单继承情形深度探索 class Base { class Derived: public Base { Derived *pd = new Derived(); Base *pb = pd; pb, pd Base 数据成员 Derived 新增数据成员 Derived 对象 Derived 型指针 pd 转换为 Base 型指针时, 地址不需要改变 70

70 多继承情形深度探索 class Base1 { class Base2 { class Derived: public Base1, public Base2 { Derived *pd = new Derived(); Base1 *pb1 = pd; Base2 *pb2 = pd; pb1, pd pb2 Base1 数据成员 Base2 数据成员 Derived 新增数据成员 Derived 对象 Derived 型指针 pd 转换为 Base2 型指针时, 原地址需要增加一个偏移量 71

71 虚拟继承情形深度探索 class Base0 { class Base1: virtual public Base0 { class Base2: virtual public Base0 { class Derived: public Base1, public Base2 { Derived *pd = new Derived(); Base1 *pb1 = pd; Base2 *pb2 = pd; Base0 *pb0 = pb1; pb1, pd pb2 pb0 Base0 指针 Base1 新增数据成员 Base0 指针 Base2 新增数据成员 Base0 数据成员 Derived 对象通过指针间接访问虚基的数据成员 72

72 基向派生的转换深度探索基向派生的转换基指针可以转换为派生指针基引用可以转换为派生引用需要用 static_cast 显式转换例 : Base *pb = new Derived(); Derived *pd = static_cast<derived *>(pb); Derived d; Base &rb = d; Derived &rd = static_cast<derived &>(rb); 73

73 型转换时的注意事项 (1) 深度探索基对象一般无法被显式转换为派生对象对象到对象的转换, 需要调用构造函数创建新的对象若派生有构造函数接收基对象 ( 或基引用 ) 的参数, 才可行 Base b; Derived d = static_cast<derived>(b); 执行基向派生的转换时, 一定要确保被转换的指针和引用所指向或引用的对象符合转换的目的型 : 对于 Derived *pd = static_cast<derived *>(pb); 一定要保证 pb 所指向的对象具有 Derived 型, 或者是 Derived 型的派生 74

74 型转换时的注意事项 (2) 深度探索如果 A 型是 B 型的虚基,A 型指针无法通过 static_cast 显式转换为 B 型的指针可以结合虚继承情况下的对象内存布局, 思考为什么不允许这种转换 void 指针参加的转换, 可能导致不可预期的后果 : 例 :Derived 公共继承自 Base1 和 Base2 Derived *pd = new Derived(); void *pv = pd; // 将 Derived 指针转换为 void 指针 Base2 *pb = static_cast<base2 *>(pv); 转换后 pb 与 pd 有相同的地址, 而正常的转换下应有一个偏移量结论 : 有 void 指针参与的转换, 兼容性规则不适用更安全更灵活的基向派生转换方式 dynamic_cast, 将在下一章介绍 75

75 小结与复习建议主要内容的继承成员的访问控制单继承与多继承派生的构造和析构函数成员的标识与访问达到的目标理解的继承关系, 学会使用继承关系实现代码的重用 76

Chapter12 Derived Classes

Chapter12 Derived Classes 继承 -- 派生类复习 1. 有下面类的说明, 有错误的语句是 : class X { A) const int a; B) X(); C) X(int val) {a=2 D) ~X(); 答案 :C 不正确, 应改成 X(int val) : a(2) { 2. 下列静态数据成员的特性中, 错误的是 A) 说明静态数

第七讲 继承与多态

第七讲继承与多态