首页 > 编程笔记 > C++笔记 阅读:5,286

C++多态的好处和作用(用实例说话)

在面向对象的程序设计中,使用多态能够增强程序的可扩充性,即程序需要修改或增加功能时,只需改动或增加较少的代码。此外,使用多态也能起到精简代码的作用。本节通过两个实例来说明多态的作用。

游戏程序实例

游戏软件的开发最能体现面向对象设计方法的优势。游戏中的人物、道具、建筑物、场景等都是很直观的对象,游戏运行的过程就是这些对象相互作用的过程。每个对象都有自己的属性和方法,不同对象也可能有共同的属性和方法,特别适合使用继承、多态等面向对象的机制。下面就以“魔法门”游戏为例来说明多态在增加程序可扩充性方面的作用。

“魔法门”游戏中有各种各样的怪物,如骑士、天使、狼、鬼,等等。每个怪物都有生命力、攻击力这两种属性。怪物能够互相攻击。一个怪物攻击另一个怪物时,被攻击者会受伤;同时,被攻击者会反击,使得攻击者也受伤。但是一个怪物反击的力量较弱,只是其自身攻击力的 1/2。

怪物主动攻击、被敌人攻击和实施反击时都有相应的动作。例如,骑士的攻击动作是挥舞宝剑,而火龙的攻击动作是喷火;怪物受到攻击会嚎叫和受伤流血,如果受伤过重,生命力被减为 0,则怪物就会倒地死去。

针对:这个游戏,该如何编写程序,才能使得游戏版本升级、要增加新的怪物时,原有的程序改动尽可能少呢?换句话说,如何才能使程序的可扩充性更好呢?

然而,无论是否使用多态,均应使每种怪物都有一个类与之对应,每个怪物就是一个对象。而且,怪物的攻击、反击和受伤等动作都是通过对象的成员函数实现的,因此需要为每个类编写 Attack、FightBack 和 Hurted 成员函数。

Attack 成员函数表现攻击动作,攻击某个怪物并调用被攻击怪物的 Hurted 成员函数,以减少被攻击怪物的生命值,同时也调用被攻击怪物的 FightBack 成员函数,遭受被攻击怪物的反击。

Hurted 成员函数减少自身生命值,并表现受伤动作。

FightBack 成员函数表现反击动作,并调用被反击对象的 Hurted 成员函数,使被反击对象受伤。

下面对比使用多态和不使用多态两种写法,来看看多态在提高程序可扩充性方面的作用。

先介绍不用多态的写法。假定用 CDmgon 类表示龙,用 CWolf 类表示狼,用 CGhost 类表示鬼,则 CDragon 类的写法大致如下(其他类的写法与之类似):
class CDragon
{
private:
    int power;  //攻击力
    int lifeValue;  //生命值
public:
    void Attack(CWolf * p);  //攻击“狼”的成员函数
    void Attack(CGhost* p);  //攻击“鬼”的成员函数
                             //……其他 Attack 重载函数
                             //表现受伤的成员函数
    void Hurted(int nPower);
    void FightBack(CWolf * p);  //反击“狼”的成员函数
    void FightBack(CGhost* p);  //反击“鬼”的成员函数
                                //......其他FightBack重载函数
};
各成员函数的写法如下:
void CDragon::Attack(CWolf* p)
{
    p->Hurted(power);
    p->FightBack(this);
}
void CDragon::Attack(CGhost* p)
{
    p->Hurted(power);
    p->FightBack(this);
}
void CDragon::Hurted(int nPower)
{
    lifeValue -= nPower;
}
void CDragon::FightBack(CWolf* p)
{
    p->Hurted(power / 2);
}
void CDragon::FightBack(CGhost* p)
{
    p->Hurted(power / 2);
}
第 1 行,Attack 函数的参数 p 指向被攻击的 CWolf 对象。

第 3 行,在 p 所指向的对象上面执行 Hurted 成员函数,使被攻击的“狼”对象受伤。调用 Hurted 成员函数时,参数是攻击者“龙”对象的攻击力。

第 4 行,以指向攻击者自身的 this 指针为参数,调用被攻击者的 FightBack 成员函数,接受被攻击者的反击。

在真实的游戏程序中,CDragon 类的 Attack 成员函数中还应包含表现“龙”在攻击时的动作和声音的代码。

第 13 行,一个对象的 Hurted 成员函数被调用会导致该对象的生命值减少,减少的量等于攻击者的攻击力。当然,在真实的程序中,Hurted 成员函数还应包含表现受伤时动作的代码,以及生命值如果减至小于或等于零,则倒地死去的代码。

第 17 行,p 指向的是实施攻击者。对攻击者进行反击,实际上就是调用攻击者的 Hurted 成员函数使其受伤。其受到的伤害的大小等于实施反击者的攻击力的一半(反击的力量不如主动攻击大)。当然,FightBack 成员函数中其实也应包含表现反击动作的代码。

实际上,如果游戏中有 n 种怪物,CDragon 类中就会有 n 个 Attack 成员函数,用于攻击 n 种怪物。当然,也会有 71 个 FightBack 成员函数(这里假设两条龙也能互相攻击)。对于其他类,如 CWolf 类等,也是这样。

以上为非多态的实现方法。如果游戏版本升级,增加了新的怪物“雷鸟”,假设其类名为 CThunderBird,则程序需要做哪些改动呢?

除了编写一个 CThiinderBird 类外,所有的类都需要增加以下两个成员函数,用以对“雷鸟”实施攻击,以及在被“雷鸟”攻击时对其进行反击:
void Attack(CThunderBird* p);
void FightBack(CThunderBird* p);
这样,在怪物种类多的时候,工作量会比较大。

实际上,在非多态的实现中,使代码更精简的做法是将 CDragon、CWolf 等类的共同特点 抽取出来,形成一个 CCreature 类,然后再从 CCreature 类派生出 CDragon、CWolf 等类。但是由于每种怪物进行攻击、反击和受伤时的表现动作不同,CDmgon、CWdf 这些类还要实现各自的 Hurted 成员函数,以及一系列 Attack、FightBack 成员函数。因此,如果没有利用多态机制,那么即便引人基类 CCreature,对程序的可扩充性也没有太大帮助。

下面再来看看,如果使用多态机制编写这个程序,在要新增 CThunderBird 类时,程序改动的情况。使用多态的写法如下:设置一个基类 CCreature,概括所有怪物的共同特点。所有具体的怪物类,如 CDragon、CWolf、CGhost 等,均从 CCreature 类派生而来。下面是 CCreature 类的写法:
class CCreature {  //“怪物”类
protected:
    int lifeValue, power;
public:
    virtual void Attack(CCreature* p) {};
    virtual void Hurted(int nPower) {};
    virtual void FightBack(CCreature* p) {};
};
可以看到,基类 CCreature 中只有一个 Attack 成员函数,也只有一个 FightBack 成员函数。

实际上,所有 CCreature 类的派生类也都只有一个 Attack 成员函数和一个 FightBack 成员函数。例如,CDragon 类的写法如下:
class CDragon : public CCreature
{
public:
    virtual void Attack(CCreature* p) {
        p->Hurted(power);
        p->FightBack(this);
    }
    virtual int Hurted(int nPower) {
        lifeValue -= nPower;
    }
    virtual int FightBack(CCreature* p) {
        p->Hurted(power / 2);
    }
};
CDragon 类的成员函数中省略了表现动作和声音的那部分代码。其他类的写法和 CDragon 类类似,只是实现动作和声音的代码不同。如何实现动画的动作和声音不是本书要讲述的内容。

在上述多态的写法中,当需要增加新怪物“雷鸟”时,只需要编写新类 CThunderBird 即可,不需要在已有的类中专门为新怪物增加 void Attack(CThunderBird * p) 和 void FightBack(CThunderBird* p) 这两个成员函数。也就是说,其他类根本不用修改。这样一来,和前面非多态的实现方法相比,程序的可扩充性当然大大提高了。实际上,即便不考虑可扩充性的问题,程序本身也比非多态的写法大大精简了。

为什么 CDragon 等类只需要一个 Attack 函数,就能够实现对所有怪物的攻击呢?

假定有以下代码片段:
CDragon dragon;
CWolf wolf;
CGhost ghost;
CThunderBird bird;
Dragon.Attack(&wolf);
Dragon.Attack(&ghost);
Dragon.Attack(&bird);
根据赋值兼容规则,上面第 5、6、7 行中的参数都与基类指针类型 CCreature* 相匹配,所以编译没有问题。从 5、6、7 三行进入 CDragon::Attack 函数后,执行 p-> Hurted(power) 语句时,p 分别指向的是 wolf、ghost 和 bird,根据多态的规则,分别调用的就是 CWolf::Hurted、CGhost::Hurted 和 CBird: Hurted 函数。

FightBack 函数的情况和 Attack 函数类似,不再赘述。

几何形体程序实例

例题:编写一个几何形体处理程序,输入几何形体的个数以及每个几何形体的形状和参数,要求按面积从小到大依次输出每个几何形体的种类及面积。假设几何形体的总薮不超过 100 个。

例如,输入
4
R 3 5
C 9
T 3 4 5
R 2 2

表示一共有 4 个几何形体,第一个是矩形(R 代表矩形),宽度和高度分别是 3 和 5;第二个是圆形(C 代表圆形),半径是 9;第三个是三角形(T代表三角形),三条边的长度分别是 3,4,5;第四个是矩形,宽度和高度都是 2。

应当输出:
Rectangle:4
Triangle:6
Rectangle:15
Circle:254.34

该程序可以运用多态机制编写,不但便于扩充(添加新的几何形体),还能够节省代码量。程序如下:
#include <iostream>
#include <cmath>
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();
};
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();
};
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;
}
CShape *pShapes[100]; //用来存放各种几何形体,假设不超过100个
int MyCompare(const void *s1, const void *s2)  //定义排序规则的函数
{
    CShape **p1 = (CShape **)s1; //s1是指向指针的指针,其指向的指针为CShape* 类型
    CShape **p2 = ( CShape **)s2;
    double a1 = (*p1)->Area(); //p1指向几何形体对象的指针, *p1才指向几何形体对象
    double a2 = (*p2)->Area();
    if( a1 < a2 )
        return -1;   //面积小的排前面
    else if (a2 < a1)
        return 1;
    else
        return 0;
}
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();
        delete pShapes[i]; //释放空间
    }
    return 0;
}
程序涉及三种几何形体。如果不使用多态,就需要用三个数组分别存放三种几何形体,不但编码麻烦,而且如果以后要增加新的几何形体,就要增加新的数组,扩充性不好。

本程序将所有几何形体的共同点抽象出来,形成一个基类 CShape,CRectangle、CCircle 等各种几何形体类都由 CShape 类派生而来。每个类都有各自的计算面积函数 Area 和显示信息函数 PrintInfo,这两个函数在所有类中都有,而且都是虚函数。

第 50 行定义了一个 CShape * pShapes[100] 数组。由于基类指针也能指向派生类对象,因此,每输入一个几何形体,就动态分配一个与该形体对应的类的对象(第 74、79、84 行), 然后将该对象的指针存入 pShapes 数组(第 76、81、86 行)。总之,pShapes 数组中的元素可能指向 CRectangle 对象,也可能指向 CCircle 对象,还可能指向 CTriangle 对象。

第 90 行对 pShapes 数组进行排序。排序的规则是按数组元素所指向的对象的面积从小到大排序。注意,待排序的数组元素是指针而不是对象,因此调用 qsort 时的第三个参数是 sizeof (CShape *),而不是 sizeof(CShape)。

在定义排序规则的 MyCompare 函数中,形参 s1(s2 与 s1 类似)指向的是待排序的数组元素,数组元素是指针,因而 s1 是指向指针的指针,其指向的指针是 CShape* 类型。*s1是数组元素,即指向对象的指针,**s1才是几何形体对象。

由于 s1 是 void* 类型的,*s1 无定义,因此要先将 s1 转换为 CShape** 类型的指针 p1(第 53 行),此后,*p1 即是一个 CShape* 类型的指针,*p1 指向一个几何形体对象,通过(*p1)->Area()就能求该对象的面积了(第 55 行)。(* p1) -> Area();这条语句是多态的,因为 *p1 是基类指针,Area 是虚函数。程序运行到此时,*p1 指向哪种对象,就会调用相应类的计算面积函数 Area,正确求得其面积。

如果不使用多态,就需要将不同形体的面积一一求出来,存到另外一个数组中,然后再排序,排序后还要维持面积值和其所属的几何形体的对应关系——这显然是比较麻烦的。

多态的作用还体现在第 91、92 行。只要用一个循环遍历排好序的 pShapes 数组,并通过数组元素调用 PrintInfo 虚函数,就能正确执行不同形体对象的 PrintInfo 成员函数,输出形体对象的信息。

上面这个使用了多态机制的程序,不但编码比较简单,可扩充性也较好。如果程序需要增加新的几何形体类,所要做的事情也只是从 CShape 类派生出新类,然后在第 72 行的 switch 语句中加入一个分支即可。

第 93 行释放动态分配的对象。按照本程序的写法,这条语句是有一些问题的。具体是什么问题,如何解决,将在《虚析构函数》一节中解释。

编程帮,一个分享编程知识的公众号。跟着站长一起学习,每天都有进步。

通俗易懂,深入浅出,一篇文章只讲一个知识点。

文章不深奥,不需要钻研,在公交、在地铁、在厕所都可以阅读,随时随地涨姿势。

文章不涉及代码,不烧脑细胞,人人都可以学习。

当你决定关注「编程帮」,你已然超越了90%的程序员!

编程帮二维码
微信扫描二维码关注