第六章 多态与虚函数

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

引言

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

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

虚函数

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

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

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

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

多态有两种表现形式

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

通过基类指针调用基类和派生类中的同名虚函数时:
（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;
}

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

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

通过基类引用调用基类和派生类中的同名虚函数时:
（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成员函数，使被反击对象受伤。
  

非多态的实现方法

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 );
  }
}

非多态的实现方法的缺点

多态的实现方法

//基类 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) { }
};

//派生类 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); //多态
} 

原理

CDragon Dragon; CWolf Wolf; CGhost Ghost;
CThunderBird Bird；
Dragon.Attack( & Wolf); //(1)
Dragon.Attack( & Ghost); //(2)
Dragon.Attack( & Bird); //(3) 

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