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是抽象类，不能创建对象

• 在抽象类的成员函数内可以调用纯虚函数（多态），而在构造函数和析构函数内不能调用纯虚函数（不是多态）。
• 如果一个类从抽象类派生而来，那么当且仅当它实现了基类中的所有纯虚函数，它才能成为非抽象类。