第六章 多态与虚函数

6.1 多态和虚函数的基本概念

引言

多态是面向对象程序设计里面非常重要的这个机制。它能很有效的提高程序的可扩充性。

有些程序设计语言有被对象继承的概念，但是没有多态的概念，那这样的程序设计语言只能被称作基于对象的程序设计语言，而不能称为面向对象的语言， 比方说visual basic。

虚函数

在类的定义中，前面有 virtual 关键字的成员函数就是虚函数。

class base {
  <span style="color:#ff0000;">virtual</span> int get() ;
};
int base::get()
{ }

virtual 关键字只用在类定义里的函数声明中，写函数体时不用。

构造函数和静态成员函数不能是虚函数。

虚函数跟普通函数的本质差别实际上就在于虚函数可以参与多态， 而普通的成员函数不能。

多态有两种表现形式

多态的表现形式一，基类指针

派生类的指针可以赋给基类指针。（赋值兼容规则）

通过基类指针调用基类和派生类中的同名虚函数时:

（1）若该指针指向一个基类的对象，那么被调用是基类的虚函数；

（2）若该指针指向一个派生类的对象，那么被调用的是派生类的虚函数。

这种机制就叫做“多态”。

示例

class CBase {
  public:
    virtual void SomeVirtualFunction() { }
};
class CDerived:public CBase {
  public :
    virtual void SomeVirtualFunction() { }
};
int main() {
  CDerived ODerived;
  CBase * p = & ODerived;
  p -> SomeVirtualFunction(); //调用哪个虚函数取决于<span style="color:#ff0000;">p指向哪种类型的对象，而不是p的指针类型</span>
  return 0;
}

在编译的时候是没有办法确定这条语句调用哪一个类的SomeVirtualFunction的。

多态的表现形式二，基类引用

派生类的对象可以赋给基类引用

通过基类引用调用基类和派生类中的同名虚函数时:

（1）若该引用引用的是一个基类的对象，那么被调用是基类的虚函数；

（2）若该引用引用的是一个派生类的对象，那么被调用的是派生类的虚函数。

这种机制也叫做“多态”。

示例

class CBase {
  public:
    virtual void SomeVirtualFunction() { }
};
class CDerived:public CBase {
  public :
    virtual void SomeVirtualFunction() { }
};
int main() {
  CDerived ODerived;
  CBase & r = ODerived;
  r.SomeVirtualFunction(); //调用哪个虚函数取决于<span style="color:#ff0000;">r引用哪种类型的对象，而不是r的引用类型</span>
  return 0;
} 

多态的简单示例

class A {
  public :
    virtual 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 ; }
};

int main() {
  A a; B b; E e; D d;
  A * pa = &a; B * pb = &b;
  D * pd = &d ; E * pe = &e;
  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;
}

多态的作用

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

6.2 使用多态的游戏程序实例

游戏《魔法门之英雄无敌》

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

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

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

基本思路：

为每个怪物类编写 Attack、FightBack和 Hurted成员函数。

• Attact函数表现攻击动作，攻击某个怪物，并调用被攻击怪物的Hurted函数，以减少被攻击怪物的生命值，同时也调用被攻击怪物的 FightBack成员函数，遭受被攻击怪物反击。
• Hurted函数减少自身生命值，并表现受伤动作。
• FightBack成员函数表现反击动作，并调用被反击对象的Hurted成员函数，使被反击对象受伤。

设置基类 CCreature，并且使CDragon, CWolf等其他类都从CCreature派生而来。

非多态的实现方法

class class CCreature {
  protected:
    int nPower ; //代表攻击力
    int nLifeValue ; //代表生命值
};
class CDragon:public CCreature {
  public:
    void Attack(CWolf * pWolf) {
      ．．．表现攻击动作的代码
      pWolf->Hurted( nPower);
      pWolf->FightBack( this);
    }
    void Attack( CGhost * pGhost) {
      ．．．表现攻击动作的代码
      pGhost->Hurted( nPower);
      pGohst->FightBack( this);
    }
    void Hurted ( int nPower) {
      ．．．．表现受伤动作的代码
      nLifeValue -= nPower;
    }
    void FightBack( CWolf * pWolf) {
      ．．．．表现反击动作的代码
      pWolf ->Hurted( nPower / 2);
    }
    void FightBack( CGhost * pGhost) {
      ．．．．表现反击动作的代码
    pGhost->Hurted( nPower / 2 );
  }
}

有n种怪物，CDragon 类中就会有n个 Attack 成员函数，以及 n个FightBack 成员函数。对于其他类也如此。

非多态的实现方法的缺点

如果游戏版本升级，增加了新的怪物雷鸟 CThunderBird，则程序改动较大。

所有的类都需要增加两个成员函数:void Attack( CThunderBird * pThunderBird) ; void FightBack( CThunderBird * pThunderBird) ;

在怪物种类多的时候，工作量较大有木有！！！

多态的实现方法

//基类 CCreature：
class CCreature {
  protected :
    int m_nLifeValue, m_nPower;
  public:
    virtual void Attack( CCreature * pCreature) {}
    virtual void Hurted( int nPower) { }
    virtual void FightBack( CCreature * pCreature) { }
};

基类只有一个 Attack 成员函数；也只有一个 FightBack成员函数；所有CCreature 的派生类也是这样。

//派生类 CDragon:
class CDragon : public CCreature {
  public:
    virtual void Attack( CCreature * pCreature);
    virtual void Hurted( int nPower);
    virtual void FightBack( CCreature * pCreature);
};
void CDragon::Attack(CCreature * p)
{
  …表现攻击动作的代码
  p->Hurted(m_nPower); //多态
  p->FightBack(this); //多态
}
void CDragon::Hurted( int nPower)
{
  …表现受伤动作的代码
  m_nLifeValue-= nPower;
}
void CDragon::FightBack(CCreature * p)
{
  …表现反击动作的代码
  p->Hurted(m_nPower/2); //多态
} 

多态实现方法的优势

如果游戏版本升级，增加了新的怪物雷鸟 CThunderBird……

只需要编写新类CThunderBird, 不需要在已有的类里专门为新怪物增加：

void Attack( CThunderBird * pThunderBird) ;

void FightBack( CThunderBird * pThunderBird) ;

成员函数，已有的类可以原封不动，没压力啊！！！

原理

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

void CDragon::Attack(<span style="color:#3333ff;">CCreature * p</span>)
{
  p->Hurted(m_nPower); //多态
  p->FightBack(this); //多态
} 

6.3 更多多态程序实例

几何形体处理程序

几何形体处理程序: 输入若干个几何形体的参数，要求按面积排序输出。输出时要指明形状。

Input:

第一行是几何形体数目n（不超过100).下面有n行，每行以一个字母c开头.

若 c 是 ‘R’，则代表一个矩形，本行后面跟着两个整数，分别是矩形的宽和高；

若 c 是 ‘C’，则代表一个圆，本行后面跟着一个整数代表其半径；

若 c 是 ‘T’，则代表一个三角形，本行后面跟着三个整数，代表三条边的长度。

Output:

按面积从小到大依次输出每个几何形体的种类及面积。每行一个几何形体，输出格式为：

形体名称：面积