1. 虚函数和多态的基本概念
1 虚函数
在类的定义中,前面有 virtual 关键字的成员函数就是虚函数。
class base
{
virtual int get();
};
int base::get() { }
- virtual 关键字只用在类定义里的函数声明中,写函数体时不用。
- 构造函数和静态成员函数不能是虚函数。
2 多态
多态的表现形式一:派生类的指针可以赋值给基类指针。
通过基类指针调用基类和派生类中的同名虚函数时:
- 若该指针指向一个基类的对象,那么被调用的是基类的虚函数。
- 若该指针指向一个派生类的对象,那么被调用的是派生类的虚函数。
这种机制就叫做“多态”。
#include <iostream>
using namespace std;
class CBase
{
public:
virtual void SomeVirtualFunction()
{
cout<<"base"<<endl;
}
};
class CDerived:public CBase
{
public:
virtual void SomeVirtualFunction()
{
cout<<"derived"<<endl;
}
};
int main()
{
CDerived ODerived;
CBase *p = &ODerived;
p->SomeVirtualFunction(); //基类指针指向了派生类对象,因此调用派生类的虚函数
system("pause");
return 0;
}
多态的表现形式二:派生类的对象可以赋值给基类的引用。
通过基类引用调用基类和派生类中的同名虚函数时:
- 若该引用引用的是一个基类的对象,那么被调用的是基类的虚函数。
- 若该引用引用的是一个派生类的对象,那么被调用的是派生类的虚函数。
这种机制也叫做“多态”。
int main()
{
CDerived ODerived;
CBase & r = ODerived;
r.SomeVirtualFunction(); //基类引用引用的是派生类对象,因此调用派生类的虚函数
system("pause");
return 0;
}
多态的作用:在面向对象的程序设计中使用多态,能够增强程序的可扩充性,即程序需要修改或增加功能的时候,需要改动和增加的代码较少。
3 多态使用的实例:游戏《魔法门之英雄无敌》
- 游戏中有很多种怪物,每种怪物都有一个类与之对应,每个怪物就是一个对象。
- 怪物能够互相攻击,攻击敌人和被攻击时都有相应的动作,动作是通过对象的成员函数实现的。
- 为每个怪物类编写 Attack、FightBack 和 Hurted 成员函数。
- Attack 函数表现攻击动作,攻击某个怪物,并调用被攻击怪物的 Hurted 函数,以减少被攻击怪物的生命值,同时也调用被攻击怪物的 FightBack 函数,遭受被攻击怪物的反击。
- Hurted 函数减少自身生命值,并表现受伤动作。
- FightBack 函数表现反击动作,并调用被反击对象的 Hurted 函数,使被反击对象受伤。
- 设置基类 CCreature,并且使 CDragon,CWolf 等其它类都从 CCreature 派生而来。
非多态实现方法:
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);
pGhost->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);
多态的实现方法:
//多态的实现方法
class CCreature
{
protected:
int m_nPower; //代表攻击力
int m_nLifeValue; //代表生命值
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 * pCreature)
{
//...表现攻击动作的代码
pCreature->Hurted(m_nPower); //多态。pCreature指针指向哪个对象,就调用哪个对象的Hurted 虚函数
pCreature->FightBack(this); //多态
}
void CDragon::Hurted(int nPower)
{
//... 表现受伤动作的代码
m_nLifeValue -=nPower;
}
void CDragon::FightBack(CCreature * pCreature)
{
//...表现反击动作的代码
pCreature->Hurted(m_nPower/2); //多态
}
int main()
{
CDragon Dragon;
CWolf Wolf;
CGhost Ghost;
CThunderBird ThunderBird;
Dragon.Attack(& Wolf);
Dragon.Attack(& Ghost);
Dragon.Attack(& ThunderBird); //派生类指针可以赋值给基类指针
}
如果游戏版本升级,增加了新的怪物雷鸟 CThunderBird。只需要编写新类 CThunderBird,不需要在已有的类里专门为新怪物增加:void Attack(CThunderBird * pThunderBird); void FightBack(CThunderBird * pThunderBird); 成员函数,已有的类可以原封不动。
4 多态使用的实例:几何形体处理程序
#include <iostream>
#include <stdlib.h>
#include <math.h>
using namespace std;
class CShape
{
public:
virtual double Area() = 0; //纯虚函数(因为没有一种形状为 Shape 类型)
virtual void PrintInfo() = 0;
};
class CRectangle:public CShape
{
public:
int w,h;
virtual double Area();
virtual void PrintInfo();
};
double CRectangle::Area()
{
return w * h;
}
void CRectangle::PrintInfo()
{
cout<<"Rectangle:"<<Area()<<endl;
}
class CCircle:public CShape
{
public:
int r;
virtual double Area();
virtual void PrintInfo();
};
double CCircle::Area()
{
return 3.14 * r * r;
}
void CCircle::PrintInfo()
{
cout<<"Circle:"<<Area()<<endl;
}
class CTriangle:public CShape
{
public:
int a,b,c;
virtual double Area();
virtual void PrintInfo();
};
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];
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;
}
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();
system("pause");
return 0;
}
如果添加新的几何形体,比如五边形,则只需要从 CShape 派生出 CPentagon,以及在 main 中的 switch 语句中增加一个 case,其余部分不变。
用基类指针数组存放指向各种派生类对象的指针。然后遍历该数组,就能对各个派生类对象做各种操作。这是很常用的做法。
5 多态使用的实例三
#include <iostream>
using namespace std;
class Base
{
public:
void fun1() { fun2();} //等价于 this->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(); //该句不是多态 //输出:Derived::fun2()
system("pause");
return 0;
}
- 在非构造函数、非析构函数的成员函数中调用虚函数,也是多态。
- 在构造函数和析构函数中调用虚函数,不是多态。编译时即可确定,调用的函数是自己的类或基类中定义的函数,不会等到运行时才决定调用自己的还是派生类的函数。
- 派生类中和基类中虚函数同名同参数表的函数,不加 virtual 也自动成为虚函数。
2. 多态的实现原理
多态实现的关键:虚函数表
每一个有虚函数的类(或有虚函数的类的派生类)都有一个虚函数表,该类的任何对象中都放着虚函数表的指针。虚函数表中列出了该类的虚函数地址。多出来的4个字节就是用来放虚函数表的地址的。
多态的函数调用语句被编译成一系列根据基类指针所指向的(或基类引用所引用的)对象中存放的虚函数的地址,在虚函数表中查找虚函数地址,并调用虚函数的指令。
3. 虚析构函数、纯虚函数和抽象类
1 虚析构函数
- 通过基类的指针删除派生类对象时,通常情况下只调用基类的析构函数。
- 但是,删除一个派生类的对象时,应该先调用派生类的析构函数,然后调用基类的析构函数。
解决办法:把基类的析构函数声明为 virtual(虚函数)
- 派生类的析构函数可以 virtual 不进行声明
- 通过基类的指针删除派生类对象时,首先调用派生类的析构函数,然后调用基类的析构函数。
一般来说,一个类如果定义了虚函数,则应该将析构函数也定义成虚函数。或者,一个类打算作为基类使用,也应该将析构函数定义成虚函数。
注意:不允许以虚函数作为构造函数。
2 纯虚函数和抽象类
- 纯虚函数:没有函数体的虚函数
virtual void print() = 0; //纯虚函数
virtual void print() { }; //非纯虚函数,虽然函数体为空,但是有函数体
- 抽象类:包含纯虚函数的类
- 抽象类只能作为基类来派生新类使用,不能创建抽象类的对象。(如之前的 CShape 类就是抽象类,没有shape 这种形状,所以只能作为基类,无法创建这种形状的对象)
- 抽象类的指针和引用可以指向由抽象类派生出来的类的对象
A a ; //错,A是抽象类,不能创建对象
A * pa ; //ok。可以定义抽象类的指针和引用
pa = new A ; //错误,A是抽象类,不能创建对象
- 在抽象类的成员函数内可以调用纯虚函数(多态),而在构造函数和析构函数内不能调用纯虚函数(不是多态)。
- 如果一个类从抽象类派生而来,那么当且仅当它实现了基类中的所有纯虚函数,它才能成为非抽象类。