C++ 程序设计 Week6 多态和虚函数

多态和虚函数基本概念

虚函数: 类定义中含virtual 关键字的为虚函数
多态:
1. 派生类的指针可以赋给基类指针
通过基类指针调用基类和派生类中的同名虚函数时:

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

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

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

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

使用多态的游戏设计实例

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

游戏中有很多种怪物，每种怪物都有一个类与之对应，
每个怪物就是一个对象。
类：CSoldier
类：CDragon
类 : 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 );
}
};

非多态实现方法缺点

如果游戏版本升级，增加了新的怪物雷鸟 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) { }
};

//派生类 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

更多多态程序实例

几何形体处理程序

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

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

Sample Input: 3
R 3 5
C 9
T 3 4 5
Sample Output
Triangle:6
Rectangle:15
Circle:254.34

问题分析:

• 有一个类的大小比较问题, 我们可以用qsort排序, 那么需要数组里面的类型一致, 我们采用Cshape类,
• 编写对应compare函数时, 需要调用对应类的面积函数, 所以我们需要将面积函数设计位虚函数
• 最后对于排好的序列, 也需要调用对应的打印函数, 所以printInfo()函数也是虚函数

basic class

#include <iostream>
#include <stdlib.h>
#include <math.h>
using namespace std;
class CShape
{
 public:
 virtual double Area() = 0; //纯虚函数
 virtual void PrintInfo() = 0;
};

derived class

//CRectangle类
class CRectangle:public CShape
{
 public:
 int w,h;
 virtual double Area();
 virtual void PrintInfo();
};
//CCircle类
class CCircle:public CShape {
 public:
 int r;
 virtual double Area();
 virtual void PrintInfo();
};
//CCircle类
class CTriangle:public CShape {
 public:
 int a,b,c;
 virtual double Area();
 virtual void PrintInfo();
};

//函数实现
double CRectangle::Area() {
return w * h;
}
void CRectangle::PrintInfo() {
 cout << "Rectangle:" << Area() << endl;
}
double CCircle::Area() {
 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;
}

Compare函数

int MyCompare(const void * s1, const void * s2)
{
 double a1,a2;
 CShape * * p1 ; // s1,s2 是 void * ，不可写 “* s1”来取得s1指向的内容
 CShape * * p2;
 p1 = ( CShape * * ) s1; //s1,s2指向pShapes数组中的元素，数组元素的类型是CShape *
 p2 = ( CShape * * ) s2; // 故 p1,p2都是指向指针的指针，类型为 CShape **
 a1 = (*p1)->Area(); // * p1 的类型是 Cshape * ,是基类指针，故此句为多态
 a2 = (*p2)->Area();
 if( a1 < a2 )
 return -1;
 else if ( a2 < a1 )
 return 1;
 else
 return 0;
} 

main函数

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();
 cin >> pr->w >> pr->h;
 pShapes[i] = pr;
 break;
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,n,sizeof( CShape*),MyCompare);
 for( i = 0;i <n;i ++)
     pShapes[i]->PrintInfo();
 return 0; 
 }

用基类指针数组存放指向各种派生类对象的指针，然后遍历该数组，就能对各个派生类对象做各种操作，是很常用的做法

又一个例子

在非构造函数，非析构函数的成员函数中调用虚函数，是多态!!!
在构造函数和析构函数中调用虚函数，不是多态。编译时即可确定，调用的函数是自己的类或基类中定义的函数，不会等到运行时才决定调用自己的还是派生类的函数。

class Base {
public:
 void fun1() { fun2(); }//真实情况, this->fun2();
 virtual void fun2() { cout << "Base::fun2()" << endl; }
};
class Derived:public Base {
public:
 virtual void fun2() { cout << "Derived:fun2()" << endl; }
};
int main() {
Derived d;
Base * pBase = & d;
pBase->fun1();
return 0;
}

所以会存在多态, 如果this指针指向的是子类, 那么会调用子类的fun2()
输出： Derived:fun2()

虚函数实现原理–虚函数表

多态实现的关键 — 虚函数表
每一个有虚函数的类（或有虚函数的类的派生类）都有一个虚函数表，该类的任何对象中都放着虚函数表的指针。虚函数表中列出了该类的虚函数地址。多出来的4个字节就是用来放虚函数表的地址的。

虚构系函数

通过基类的指针删除派生类对象时

• 只调用基类的析构函数
  Vs.
  删除一个 派生类的对象时
• 先调用 派生类的析构函数
• 再调用 基类的析构函数

解决办法:
把基类的析构函数声明为virtual
例子:

class son{
 public:
 ~son() { cout<<"bye from son"<<endl; };
};
class grandson : public son{
 public:
 ~grandson(){ cout<<"bye from grandson"<<endl; };
};
int main(){
 son *pson;
pson=new grandson;
delete pson;
return 0;
}

输出结果: bye from son
没有执行grandson::~grandson()!!!

解决方法:

class son{
 public:
 virtual ~son() { cout<<"bye from son"<<endl; };
};
class grandson : public son{
 public:
 ~grandson(){ cout<<"bye from grandson"<<endl; };
};
int main() {
 son *pson;
pson= new grandson;
delete pson;
return 0;
}

输出结果: bye from grandson
bye from son