程序设计实习 第十五讲 多 态.

Presentation on theme: "程序设计实习 第十五讲 多 态."— Presentation transcript:

1 程序设计实习 第十五讲 多 态

2 关于上机考试 时间: 5月23日上午8点~11点 地点: 计算中心机房、学院机房 注意事项
助教将在5月22日晚9点后在课程网站公布每个同学机房和坐位号 注意事项 不允许带参考资料、教材、稿纸、U盘、手机等任何可用于作弊的材料和工具，一旦发现即视同作弊 其他被认定为作弊的情况 不按照指定的座位就坐 不在指定的座位上提交答案 作弊的后果非常严重：没有学位 建议每人只带一枝笔 确保至少成功提交一道上机题：只要一道题就可得60分 一道题都没有提交成功，则为0分 题目编号大体上是从易到难(教师们认为如此) 如果剩下的题目都不会做、离考试结束还有很长时间，集中精力做提交成功率高的题目：多数人会做，说明该题目不难

3 多态的基本概念 继承：子问题之间的相似性。 将每个子问题表达为一个类后，这种相似性有多种表现形式
类成员的交集非空：有共同的属性、服务 通过父类、子类的划分，将共同的属性、服务提取到父类中 成员服务的名称相同，每个类需要自己的算法实现 例如几何图形的面积，对不同类型的几何图形有不同的计算公式 成员服务的名称相同，而且算法的框架也相同，但算法实现的部分细节与具体的子问题(类)相关 例如一组带颜色的几何图形，它们的材质相同，分别使用不同的颜料刷成不同的颜色，每个几个图形的造价由面积和使用的颜料决定fun( area, color)，不同类型的几何图形有不同的面积计算公式 多态：以继承关系表达子问题的相似性时，表达类之间成员服务相似性的机制 成员服务的名称和接口(返回值类型、参数列表)相同 成员服务的算法实现不同：包含算法框架相同但部分实现细节依赖具体子问题(类)的情况

4 多态的基本概念 将每个子问题表达为一个类后，完整的表达子问题的相似性 共同的属性、服务：通过父类、子类的划分，将共同的属性、服务提取到父类中
成员服务的名称和接口(返回值类型、参数列表)相同：每个类需要自己的算法实现 将成员服务提取到父类中 在父类中将成员服务声明为虚函数(virtual) 在每个子类中分别提供该服务的实现代码 成员服务的名称和接口(返回值类型、参数列表)相同、算法的框架也相同：算法实现的部分细节与具体的子问题(类)相关 将算法中与具体子问题(类)相关那部分实现细节定义为父类的虚函数 在每个子类中分别提供相应虚函数的实现代码

5 多态的三种形态 1、派生类的指针可以赋给基类指针。 通过基类指针调用基类和派生类中的同名虚函数（一种特殊的成员函数)时，若该指针指向一个基类的对象，那么被调用是基类的虚函数，如果该指针指向一个派生类的对象，那么被调用的是派生类的虚函数。例 CBase * p = &ODerived; p -> SomeVirtualFunction();

6 2、派生类的对象可以赋给基类引用。 通过该基类引用调用基类和派生类中的同名虚函数时，若该引用引用的是一个基类的对象，那么被调用是基类的虚函数，如果引用的是一个派生类的对象，那么被调用的是派生类的虚函数。这种机制也叫 “多态”。例： CBase & r = ODerived; r.SomeVirtualFunction(); 3、在派生类的对象中访问基类的成员函数，如果该函数调用了虚函数，则在该函数执行时调用派生类中定义的同名虚函数。

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

8 多态的例子 class A { public : virtual void Print( ) { cout << “A::Print”<<endl ; } }; class B:public A { 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 ; }

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

10 动态联编： 一条函数调用语句在编译时无法确定调用哪个函数，运行到该语句时才确定调用哪个函数，这种机制叫动态联编

11 为什么需要动态联编： class A {public: virtual void Get(); };
class B : public A { public: virtual void Get(); }; void MyFunction( A * pa ) { pa->Get(); } pa->Get() 调用的是 A::Get()还是B::Get(),编译时无法确定，因为不知道MyFunction被调用时，形参会对应于一个 A 对象还是B对象。 所以只能等程序运行到 pa->Get（）了，才能决定到底调用哪个Get()

12 多态的又一例子 class Base { public: void fun1() { fun2(); }
void virtual fun2() { cout << "Base::fun2()" << endl; } }; class Derived:public Base { virtual void fun2() { cout << "Derived:fun2()" << endl; } main() { Derived d; Base * pBase = & d; pBase -> fun1();　　 // 输出： Derived:fun2()

13 调用的次序是：Base::fun1() -> Derived::fun2();
因为 void fun1() { fun2(); } 相当于 this->fun2(); 编译这个函数的代码的时候，由于fun2()是虚函数，this是基类指针，所以是动态联编 上面这个程序运行到fun1函数中时， this指针指向的是d ,所以经过动态联编，调用的是Derived::fun2()

14 多态的作用 　　在面向对象的程序设计中使用多态，能够增强程序的可扩充性，即程序需要修改或增加功能的时候，需要改动和增加的代码较少

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

16 类：CSoldier 类：CAngel 类：CDragon 类CPhonex 游戏中有很多种怪物，每种怪物都有一个类与之对应，每个怪物就是一个对象

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

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

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

20 非多态的实现方法 class CDragon { private: int nPower ; /代表攻击力
int nLifeValue ; //代表生命值 public: int Attack( CWolf * pWolf) { ．．．表现攻击动作的代码 pWolf->Hurted( nPower); pWolf->FightBack( this); } int Attack( CGhost * pGhost) { pGhost->Hurted( nPower); pGohst->FightBack( this);

21 int Hurted ( int nPower) {
．．．．表现受伤动作的代码 nLifeValue -= nPower; } int FightBack( CWolf * pWolf) { ．．．．表现反击动作的代码 pWolf ->Hurt( nPower / 2); int FightBack( CＧhost * pGhost) { pGhost->Hurt( nPower / 2 ); 有n种怪物，CDragon 类中就会有n个 Attack 成员函数，以及 n个FightBack 成员函数，对于其他类，比如CWolf等，也是这样

22 以上为非多态的实现方法。如果游戏版本升级,增加了新的怪物雷鸟 CThunderBird, 则程序改动较大, 所有的类都需要增加:
int Attack( CThunderBird * pThunderBird) ; int FightBack( CThunderBird * pThunderBird) ; 成员函数，在怪物种类多的时候，工作量较大

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

24 基类 CCreature： class CCreature { private : int nLifeValue, nPower; public: virtual void Attack( CCreature * pCreature) = 0; virtual int Hurted( int nPower) = 0; virtual int FightBack( CCreature * pCreature) = 0; } 基类只有一个　Attack 成员函数 也只有一个　FightBadk成员函数 所有CCreature 的派生类也是这样

25 class CDragon : public CCreature { public:
virtual void Attack( CCreature * pCreature) { pCreature ->Hurted( nPower); pCreature ->FightBack( this); } virtual int Hurted( int nPower) { … }; virtual int FightBack( CCreature * pCreature) { …}; 那么当增加新怪物雷鸟的时候,只需要编写新类CThunderBird, 不需要在已有的类里专门为新怪物增加 int Attack( CThunderBird * pThunderBird) ; int FightBack( CThunderBird * pThunderBird) ; 成员函数

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

27 使用多态增强程序扩充性的另一例子： 家庭动物管理程序, 能加进新动物，能输出家里所有动物的名字 class Dog { public:
char szName[20]; void PrintName() { prnitf( “this is dog %s”, szName) } Dog ( char * Name ) { strcpy( szName,Name) ; } }; class Cat { public: prnitf( “this is cat %s”, szName) Cat ( char * Name ) { strcpy( szName,Name) ; }

28 class Home { public: int nDogs; int nCats; Dog * pDogs [ 20]; Cat * pCats [20]; void PrintAll () ; void Add( Dog * pDog); void Add ( Cat * pCat); Home ( ) { nDogs =0; nCats = 0 ; } }; void Home::Add( Dog * pDog) { pDogs[ nDogs ++ ] = pDog; } void Home::Add( Cat * pCat) { pCats[ nCats ++ ] = pCat; }

29 void Home::PrintAll () {
for( int i = 0; i < nCats ; i ++ ) pCats[i] -> PrintName (); for(i = 0; i < nDogs ; i ++ ) pDogs[i] -> PrintName (); } Home MyHome; char szName[20]; main ( ) { while ( true) { cin >> szName ; if ( IsDog ( szName) ) MyHome.Add( new Dog ( szName)); else if ( IsCat( szName)) MyHome.Add( new Cat ( szName)); MyHome.PrintAll (); }

30 不便于扩充，添加新动物时要改写Home 类
多态实现方法： 增加 Animal 类, Cat 和Dog 都从Animal 派生 class Animal { public: char szName[20]; virtual void PrintName () { } }; class Dog : public Animal { virtual void PrintName () { printf( “this is dog %s”, szName); }

31 class Cat : public Animal {
virtual void PrintName () { printf( “this is cat %s”, szName); } }; class Home { int nAnimals; Animal * pAnimal [20]; void PrintAll () ; void Add( pAnimal * pAnimal); Home ( ) { nAnimals =0; }

32 void Home::Add( Animal * Animal )
{ pAnimal [ nAnimals ++ ] = Animal; } void Home::PrintAll ( ) for( int i = 0;i < nAnimals; i ++ ) pAnimal[i] ->PrintName ();

33 若增加了新的 动物 Pig class Pig :public Animal { public: PrintName () {
printf( “This is pig %s”,szName); } }; main ( ) { while ( true) { cin >> szName ; if ( IsDog ( szName) ) MyHome.Add( new Dog ( szName)); else if ( IsCat( szName)) MyHome.Add(new Cat ( szName)); else if ( IsPig ( szName)) MyHome.Add(new Pig ( szName)); MyHome.PrintAll ();

34 思考 “多态”的关键在于通过基类指针或引用调用一个虚函数时，编译时不确定到底调用的是基类还是派生类的函数，运行时才确定。这到底是怎么实现的呢？

35 提示：请看下面例子程序： class Base1 { public: int i;
virtual void Print() { cout << "Base1:Print" ; } }; class Derived : public Base1{ public : 　int n; 　　 　virtual void Print() { cout <<"Drived:Print" << endl; } } main() { Derived d; cout << sizeof( Base1) << ","<< sizeof( Derived ) ; 程序运行输出结果： 8, 12

36 为什么　Base 对象的大小是８个字节而不是４个字节，为什么　Ｄerived 对象的大小是12个字节而不是8个字节，多出来的４个字节做什么用呢？和多态的实现有什么关系？

37 多态的实现：虚函数表 每一个有虚函数的类（或有虚函数的类的派生类）都有一个虚函数表，该类的任何对象中都放着虚函数表的指针。虚函数表中列出了该类的虚函数地址。多出来的4个字节就是用来放虚函数表的地址的
pBase pointer for vtable b i Base vtable pointer for Base::Print() ………其他Base类的虚函数地址…………

38 pDerived pointer for vtable b d i n Derived vtable pointer for Derived::Print() …………其他Derived类的虚函数地址………

39 多态的函数调用语句被编译成一系列根据基类指针所指向的（或基类引用所引用的）对象中存放的虚函数表的地址，在虚函数表中查找虚函数地址，并调用虚函数的过程

40 虚函数的访问权限 class Base { private:
virtual void fun2() { cout << "Base::fun2()" << endl; } }; class Derived:public Base { public: virtual void fun2() { cout << "Derived:fun2()" << endl; } Derived d; Base * pBase = & d; pBase -> fun2(); // 编译出错 编译出错是因为 fun2() 是Base的私有成员。即使运行到此时实际上调用的应该是 Derived的公有成员 fun2()也不行，因为语法检查是不考虑运行结果的。 如果 将Base中的 private换成public,即使Derived中的fun2() 是private的，编译依然能通过，也能正确调用Derived::fun2()

41 纯虚函数和抽象类 纯虚函数： 没有函数体的虚函数 class A { private: int a; public:
virtual void Print( ) = 0 ; //纯虚函数 void fun() { cout << “fun”; } }; 包含纯虚函数的类叫抽象类 抽象类只能作为基类来派生新类使用，不能创建抽象类的对象 抽象类的指针和引用可以指向由抽象类派生出来的类的对象 A a ; // 错，A 是抽象类，不能创建对象 A * pa ; // ok,可以定义抽象类的指针和引用 pa = new A ; //错误, A 是抽象类，不能创建对象 在抽象类的成员函数内可以调用纯虚函数，但是在构造函数或析构函数内部不能调用纯虚函数

42 class A { public: virtual void f() = 0; void g( ) { this->f( ) ; //ok } A( ){ f( ); // 错误 调用某个函数的指令，就是要跳转到那个函数所在地址去执行。可是纯虚函数没有函数体，即实际上不存在，跳到哪里去？

43 构造函数和析构函数中调用虚函数 在构造函数和析构函数中调用虚函数时：他们调用的函数是自己的类或基类中定义的函数，不会等到运行时才决定调用自己的还是派生类的函数。 在普通成员函数中调用虚函数，则是动态联编，是多态。 class myclass { public: virtual void hello(){cout<<"hello from myclass"<<endl; }; virtual void bye(){cout<<"bye from myclass"<<endl;}; };

44 class son:public myclass
{ public: void hello(){ cout<<"hello from son"<<endl;}; son(){hello();}; ~son(){bye();}; }; class grandson:public son void hello(){cout<<"hello from grandson"<<endl;}; grandson(){cout<<"constructing grandson"<<endl;}; ~grandson(){cout<<"destructing grandson"<<endl;};

45 //连接了myclass::hello()
main() { grandson gson; son *pson; pson=&gson; pson->hello(); //void grandson::hello() } 输出结果： hello from son// gson先创建son， son()中静态连接了son::hello() constructing grandson // gson的创建 hello from grandson // pson->hello()动态连接到grandson::hello() destructing grandson // gson的创建的析构 bye from myclass // gson中son部分的析构，~son()中静态 //连接了myclass::hello()

46 普通成员函数中调用虚函数的例子： class myclass { public: void reset();
void virtual print(void) { cout<<"myclass::print\n";return;}; }; void myclass::reset() { print(); //等效于 this->print(); this是基类指针 } class derived:public myclass void virtual print() { cout<<"derived::print\n"; };

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

48 虚析构函数 通过基类的指针删除派生类对象时，通常情况下只调用基类的析构函数 解决办法：把基类的析构函数声明为virtual
但是，删除一个派生类的对象时，应该先调用派生类的析构函数，然后调用基类的析构函数 解决办法：把基类的析构函数声明为virtual 派生类的析构函数可以virtual不进行声明 通过基类的指针删除派生类对象时，首先调用派生类的析构函数，然后调用基类的析构函数 一般来说，一个类如果定义了虚函数，则应该将析构函数也定义成虚函数。 注意：不允许以虚函数作为构造函数

49 class son {public: ~son() {cout<<"bye from son"<<endl;}; }; class grandson:public son ~grandson(){cout<<"bye from grandson"<<endl;}; main() { son *pson; pson=new grandson; delete pson; } 输出结果： bye from son 没有执行grandson::~grandson()!!!

50 class son {public: virtual ~son() {cout<<"bye from son"<<endl;}; }; class grandson:public son ~grandson(){cout<<"bye from grandson"<<endl;}; main() { son *pson; pson=new grandson; delete pson; } 输出结果： bye from grandson bye from son 执行grandson::~grandson()，引起执行son::~son()！！！