多态和虚函数基本概念
虚函数: 类定义中含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