Microsoft PowerPoint - 第07讲_多态1.ppt [兼容模式]

Transcription

1 程序设计实习 (I): C++ 程序设计 第七讲多态

2 上节内容回顾 基本概念 : 继承 基类 派生类 派生类的成员组成 可见性 派生类的构造 析构 派生类与基类的指针类型转换 2

3 回顾 : public 继承 class base { private: int m; public: int q; base(int ti=0):m(i){} }; class derived : public base { public: int n; derived(int j=0):base(j){} }; base b; derived d; private: int m; public: int q; base 类 派生 derived 类 base 部分 private: int m; public: int q; derived 部分 public: int n; 3

4 回顾 : 基类与派生类的赋值兼容 派生类的对象可以赋值给基类对象 该对象不包含派生类定义的成员, 因为没有派生类成员的存 储空间 ( 派生类部分在赋值时被 切掉 ) *C++ Primer P489 派生类对象可以初始化基类引用 派生类对象的地址 / 指针可以赋值给基类指针 上节课例子 Base objbase(5); Derived objderived(3); base 赋值 derived Base * pbase = & objderived ; 根据指针 / 引用类型 pbase->print(); Pi // 调用基类函数 Pi Print() 来决定调用的函数 Derived * pderived = (Derived *)(& objbase); pderived->print(); // 调用派生类函数 Print() 4 4

5 主要内容 多态的基本概念 虚函数 多态的作用 动态联编 虚析构函数 纯虚函数和抽象类 5

6 主要内容 多态的基本概念 虚函数 多态的作用 动态联编 虚析构函数 纯虚函数和抽象类 6

7 多态的基本概念 派生类的指针可以赋给基类指针 通过基类指针调用基类和派生类中的同名虚函数 ( 一种 特殊的成员函数 ) 时 : (1) () 若该指针指向一个基类的对象, 那么被调用是基类的虚函数 (2) 若该指针指向一个派生类的对象, 那么被调用的是派生类的 虚函数 这种机制就叫做 多态 例如 : CBase * p = &ODerived; p -> SomeVirtualFunction(); ti // 即 : 根据指针 / 引用指向的对象类型来决定调用的函数 7

8 派生类的对象可以赋给基类引用 通过该基类引用调用基类和派生类中的同名虚函数时 : (1) 若该引用引用的是一个基类的对象, 那么被调用是基类的 虚函数 (2) 如果引用的是一个派生类的对象, 那么被调用的是派生类 的虚函数 这种机制也叫 多态 例如 : CBase & r = ODerived; r.somevirtualfunction(); 多态 就是指上述这两种机制 8

9 虚函数 在类的定义中, 前面有 virtual 关键字的成员函数就是虚函数 class base { }; virtual li int get() ; int base::get() {} virtual 关键字只用在类定义里的函数声明中, 写 函数体时不用 9

10 多态示例 1: 通过指针或者引用访问虚函数 class A { public : virtual it void Print( ) { cout << "A::Print"<<endl ; } }; class B: public A { public : virtual void Print( ) { cout << "B::Print" <<endl; } }; class D: public A { public: virtual void Print( ) { cout << "D::Print" << endl ; } }; class E: public B { virtual void Print( ) { cout << "E::Print" << endl ; } }; 10

11 int main() { A a; B b; E e; D d; A * pa = &a; B * pb = &b; D * pd = &d; E * pe = &e; B E A D } pa->print(); //a.print() 被调用, 输出 :A::Print pa = pb; // 派生类指针赋值给基类指针 pa -> Print(); //b.print() 被调用, 输出 :B::Print pa = pd; pa -> Print(); //d.print() 被调用, 输出 :D::Print pa = pe; pa -> Print(); //e.print() 被调用, 输出 :E::Print return 0; 11

12 将上述例子稍加修改 class A{ public : virtual void Print( ) { cout << A::Print <<endl ; } }; class B:public A { main 函数不变, public : 所得的结果一样 void Print( ) { cout << B::Print <<endl; } 在多层继承的 }; 情况下, 从定义 class D: public A { virtual 开始的派 public: void Print( ) { cout<< D::Print << endl ; } 生类中同名函数 }; 均为虚函数, 无 class E: public B { 论在这些派生类 void Print( ) { cout << E::Print << endl ; } 的同名函数中是 }; 否显示加 virtual 12

13 多态示例 2: 在基类的普通成员函数中访问虚函数 class myclass{ public: void reset(); void virtual print(void) //virtual 可以写在返回值前或后 { cout<<"myclass::print\n";} }; void myclass::reset() { print(); // 等效于 this->print(); this 是基类指针 } class derived: public myclass{ public: void virtual print() { cout<<"derived::print\n"; } }; 13

14 main() { myclass b; derived d; b.reset(); d.reset(); } 输出 : myclass::print derived::print 14

15 多态的作用 多态的实质 父类定义共同接口, 子类不同实现 通过父类以相同的方式操作不同子类的行为 在面向对象的程序设计中使用多态 能够增强程序的可扩充性 程序需要修改或增加功能的时候, 需要改动和增加的代码 较少 15 15

16 多态增强程序可扩充性的例子 游戏 魔法门之英雄无敌 16

17 类 CSoldier 类 CAngel 类 g 类 CDragon 类CPhoenix 游戏中有很多种怪物(其他的如Wolf Ghost) 每种怪物都有一 个类与之对应 每个怪物就是一个对象 17

18 怪物能够互相攻击 攻击敌人和被攻击时都有相 应的动作 动作是通过对象的成员函数实 的 应的动作 动作是通过对象的成员函数实现的 18

19 游戏版本升级时 要增加新的怪物 雷鸟 如 何编程才能使升级时的代码改动和增加量较小 新增类 CThunderBird 19

20 不论是否用多态编程, 基本思路都是 : 为每个怪物类编写 Attack, FightBack 和 Hurted 成员函数 Attack 函数表现攻击动作, 攻击某个怪物 并调用被攻击怪物的 Hurted 函数, 以减少被攻击怪物的生命值 同时也调用被攻击怪物的 FightBack 成员函数, 遭受被攻击怪物反击 Hurted 函数减少自身生命值, 并表现受伤动作 FightBack 函数表现反击动作, 并调用被反击对象的 Hurted 成 员函数, 使被反击对象受伤 20

21 非多态的实现方法 class CDragon { private: int npower; // 代表攻击力 int nlifevalue; // 代表生命值 public: void Attack(CWolf * pwolf) { // 攻击 Wolf 的成员函数 表现攻击动作的代码 pwolf->hurted(npower); pwolf->fightback(this); // 指向攻击者自身的 this 指针 } void Attack(CGhost * pghost) { // 攻击 Ghost 的成员函数 表现攻击动作的代码 pghost->hurted(npower); pgohst->fightback(this); } 21

22 减半 void Hurted (int npower) { 表现受伤动作的代码 nlifevalue -= npower; } void FightBack(CWolf * pwolf) { 表现反击动作的代码 pwolf ->Hurt(nPower/ 2); // 使攻击者受伤, 反攻功力 } void FightBack(CGhost t * pghost) { 表现反击动作的代码 pghost->hurt(npower/ 2); } } 有 n 种怪物,CDragon 中就会有 n 个 Attack 成员函数, 以及 n 个 FightBack 成员函数 对于其他类也如此 22

23 如果游戏版本升级, 增加了新的怪物雷鸟 CThunderBird, 则程序改动较大, 所有的类都需要增加 : void Attack( CThunderBird * pthunderbird) ; void FightBack( CThunderBird * pthunderbird) ; 在怪物种类多的时候, 工作量较大 非多态实现中, 代码更精简的做法是将 CDragon, CWolf 等类的共同特点抽取出来, 形成一个 CCreature 类, 然后再从 CCreature 类派生出 CDragon CWolf 等类 但是由于每种怪物进行攻击 反击和受伤时的表现动作不同, CDragon CWolf 这些类还是要实现各自的 Hurted 成员函数, 以 及一系列 Attack FightBack 成员函数 所以只要没有利用多态机制, 那么即便引入基类 CCreature, 对程序的可扩充性也无帮助 23

24 使用多态的实现方法 设置基类 CCreature, 并且使 CDragon, CWolf 等其他 类都从 CCreature 派生而来 CCreature CDragon CWolf CSoldier CPhoenix CAngel 24

25 基类 CCreature: class CCreature { // 怪物 类 protected : int m_nlifevalue, m_npower; public: virtual it void Attack( CCreature * pcreature); virtual void Hurted( int npower); virtual void FightBack( (CC CCreature * pcreature); }; 基类只有一个 Attack 成员函数 也只有一个 FightBack 成员函数 所有 CCreature 的派生类也是这样 25

26 派生类 CDragon: class CDragon : public CCreature { }; public: virtual void Attack( CCreature * pcreature); virtual void Hurted( int npower); virtual void FightBack( CCreature * pcreature); 26

27 void CDragon::Attack(CCreature * p) { p->hurted(m_npower); p->fightback(this); } void CDragon::Hurted( int npower) { m_nlifevalue nlifevalue-= npower; } void CDragon::FightBack(CCreature * p) { p->hurted(m >Hurted(m_nPower/2); } 27

28 那么当增加新怪物雷鸟的时候, 只需要编写新类 CThunderBird, 不需要在已有的类里专门为新怪物增加 : 成员函数 void Attack( CThunderBird d * pthunderbird); d) void FightBack( CThunderBird * pthunderbird); 28

29 具体使用这些类的代码 : CDragon Dragon; CWolf Wolf; CGhost Ghost; CThunderBird Bird; Dragon.Attack( & Wolf); //(1) () Dragon.Attack( & Ghost); //(2) Dragon.Attack( & Bird); //(3) 根据多态的规则, 上面的 (1), (2), (3) 进入到 CDragon::Attack 函 数后, 能分别调用 : CWolf::Hurted CGhost::Hurted CBird::Hurted 29

30 使用多态的另一例子 : 几何形体处理程序 : 输入若干个几何形体的参数, 要 求按面积排序输出 输出时要指明形状输出时要指明形状 Input: 第一行是几何形体数目 n ( 不超过 100), 下面有 n 行, 每行以一个 字母 c 开头 若 c 是 R, 则代表一个矩形, 本行后面跟着两个整数, 分别是矩形的宽和高若 c 是 C, 则代表一个圆, 本行后面跟着一个整数代表其半径若 c 是 T, 则代表一个三角形, 本行后面跟着三个整数, 代表 三条边的长度 30

31 使用多态的另一例子 : 几何形体处理程序 : 输入若干个几何形体的参数, 要 求按面积排序输出 输出时要指明形状 Output: 按面积从小到大依次输出每个几何形体的种类及面积 每行一 个几何形体, 输出格式为 : 形体名称 : 面积 31

32 使用多态的另一例子 : Sample Input: 3 R 3 5 C 9 T Sample Output: Triangle:6 Rectangle:15 Circle:

33 预备知识 : 快速排序库函数 qsort void qsort(void *base, int nelem, unsigned int width, int (* pfcompare)( const void *, const void *)); base 是待排序数组的起始地址 nelem 是待排序数组的元素个数 width 是待排序数组的每个元素的大小 ( 以字节为单位 ) pfcompare 是一个函数指针, 它指向一个 比较函数 该比较函数应是返回值为 int, 有两个参数为 const void * 的函数 int 函数名 (const void * elem1, const void * elem2); int 函数名 (const void elem1, const void elem2); 33

34 快速排序库函数 qsort 排序就是一个不断比较并交换位置的过程 qsort 函数在执行期间, 会通过 pfcompare 函数指针调用 比较函数, 调用时将要比较的两个元素的地址传给 比较函数, 然后根据 比较函数 返回值判断两个元素哪个更应该排在前面 这个 比较函数 不是 C/C++ 的库函数, 而是由使用 qsort 的程序员编写的 在调用 qsort 时, 将 比较函数 的名字作为实参传递给 pfcompare 程序员当然清楚该按什么规则决定哪个元素应该在前, 哪个元素应该在后, 这个规则就体现在 比较函数 中 34

35 快速排序库函数 qsort qsort 函数的用法规定, 比较函数 的原型应是 : int 函数名 (const void * elem1, const void * elem2); 该函数的两个参数,elem1 和 elem2, 指向待比较的两个元素 也就是说, * elem1 和 * elem2 就是待比较的两个元素 该函数必 须具有以下行为 : 1) 如果 * elem1 应该排在 * elem2 前面, 则函数返回值是负整数 ( 任何负整数都行 ) 2) 如果 * elem1 和 * elem2 哪个排在前面都行, 那么函数返回 0 3) 如果 * elem1 应该排在 * elem2 后面, 则函数返回值是正整数 ( 任何正整数都行 ) 35

36 #include <iostream> #include <stdlib.h> // 快速排序函数 #include <math.h> // 数学函数 using namespace std; class CShape { public: virtual double Area(){ }; virtual void PrintInfo(){ }; }; class CRectangle: public CShape { public: int w, h; virtual double Area(); virtual void PrintInfo(); }; 36

37 class CCircle: public CShape { public: int r; virtual double Area(); virtual void PrintInfo(); }; class CTriangle: public CShape { public: }; int a, b, c; virtual double Area(); virtual void PrintInfo(); 37

38 38 double CRectangle::Area() { return w * h; } void CRectangle::PrintInfo() { cout << "Rectangle:" << Area() << endl; } double CCircle::Area() e { return 3.14 * r * r ; } void CCircle::PrintInfo() { cout << "Circle:" << Area() << endl; } double CTriangle::Area() { double p = (a + b + c) / 2.0; return sqrt(p * ( p - a)*(p- b)*(p - c)); } void CTriangle::PrintInfo() { cout << "Triangle:" << Area() << endl; }

39 CShape * pshapes[100]; // 用来存放各种几何形体, 假设不超过 100 int MyCompare(const void * s1, const void * s2){ double a1, a2; CShape * * p1 ; //s1 是指向指针的指针, 其指向的指针为 Cshape* CShape * * p2; p1 = ( CShape * * ) s1; p2 = (CSh CShape **) * s2; a1 = (*p1)->area(); //p1 指向几何形体对象的指针,*p1 指向对象 a2 = (*p2)->area(); if( a1 < a2 ) return -1; else if ( a2 < a1 ) return 1; else return 0; } 39

40 int main() { int i; int n; CRectangle * pr; CCircle * pc; CTriangle * pt; cin >> n; for( i = 0; i < n; i ++ ) { char c; cin >> c; switch(c) { case 'R': pr = new CRectangle(); //new 返回的是对象指针 cin >> pr->w >> pr->h; pshapes[i] = pr; break; 40

41 41 } case 'C': pc = new CCircle(); cin >> pc->r; pshapes[i] = pc; break; case 'T': pt = new CTriangle(); cin >> pt->a >> pt->b >> pt->c; pshapes[i] = pt; break; } } qsort(pshapes, p n, sizeof( CShape*), MyCompare); for( i = 0; i <n; i ++) pshapes[i]->printinfo(); // 多态 return 0;

42 附录 : 访问机制对比 覆盖 : 所访问的对象由指针 ( 或引用 ) 的类型所决定 用派生类指针访问这类成员时, 访问的是派生类中定义的 ( 同名 ) 成员函数 用基类指针访问这类成员时, 访问的是基类的 ( 同名 ) 成员函数, 即使它指向的是一个派生类对象 Vs. 虚函数 : 所访问的对象由指针 ( 或引用 ) 所指向的对象类型所决定 若该指针 ( 或引用 ) 指向一个基类的对象, 那么被调用是基类的虚函数 如果该指针 ( 或引用 ) 指向一个派生类的对象, 那么被调用的是派生类的虚函数 42 42

43 面向对象编程的三个基本概念 : 数据抽象 继承 动态绑定 43

44 面向对象编程的三个基本概念 : 数据抽象 用类进行数据抽象, 封装 继承 派生类继承基类成员 动态绑定 多态, 编译器能够在运行时决定是 使用基类中定义的函数还是派生类中定义的函数 44

45 45