第六周：多态

第一节 虚函数和多态的基本概念

1.虚函数

在类的定义中，前面有virtual关键字的成员函数就是虚函数。

class base{

virtual int get();

}

int base::get(){}

virtual关键字只在类定义里的函数声明中，写函数体的时候不用。构造函数和静态函数不能使用virtual，即不能成为虚函数。

2.多态

（1）表现形式一

派生类的指针可以赋给基类指针。

通过基类指针调用基类和派生类中的同名虚函数时：

①若该指针指向一个基类的对象，那么背调用的是基类的虚函数；

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

这种机制称为多态。例如：

class CBase{

public:

virtual void SomeVirtualFunction(){}

};

class CDerived:public CBase{

public:

virtual void SomVirtualFunction(){}

};

int main(){

CDerived ODerived;

CBase *p = &ODerived;

p->SomeVirtualFunction();//p指向派生类对象，所以调用派生类里面的

return 0;

}

（2）表现形式二

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

通过基类引用调用基类和派生类中的同名虚函数时：

①若该引用引用的是一个基类的对象，那么被调用的是基类的虚函数；

②若该引用引用的是一个派生类的对象，那么调用的是派生类的虚函数。

class CBase{

public:

virtual void SomeVirtualFunction(){}

};

class CDerived:public CBase{

public:

virtual void SomVirtualFunction(){}

};

int main(){

CDerived ODerived;

CBase &r = ODerived;

r->SomeVirtualFunction();//在这里调用的是派生类中的

return 0;

}

3.多态的作用

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

第二节 多态实例：魔法门之英雄无敌

在游戏中有很多怪物，没种怪物都有一个类与之对应，每个怪物就是一个对象。怪物能够互相攻击，攻击敌人和被攻击时都有相应的动作，动作是通过对象的成员函数实现的。游戏版本升级时，要增加新的怪物——雷鸟（CThunderBird）。如何编程使代码改动和增加量较小？

基本思路：

为每个怪物类编写 Attack、FightBack和 Hurted成员函数。

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

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

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

设置基类CCreature，并且使CDragon、CWolf等其他类都从该基类派生而来，如图2.1所示。

图2.1 基本思路图

1.非多态实现方法：

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

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种怪物，CDrogon就要有n个Attack成员函数和n个FightBack成员函数，对于其他类也是如此。

如果游戏版本升级，增加了新的怪物雷鸟CthunderBird，则程序改动非常大，所有的类都需要增加两个成员函数（攻击和反击）。

2.多态实现方法：

代码如下：

class class CCreature {

protected:

int nPower ; //代表攻击力

int nLifeValue ; //代表生命值

public:

virtual void Attack(CCreature *pCreature){}

virtual void Hurted(int nPower){}

virtual void FightBack(CCreature *pCreature){}

};

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

pWolf->FightBack(this);

}

void CDragon::Hurted(int nPower){

//表现受伤动作代码

m_nLifeValue -=nPower;

}

void CDragon::FightBack(CCreature *p){

//表现反击动作的代码

pWolf->Hurted(m_nPower/2);

}

基类只有一个Attack、FightBack成员函数，所有CCreature的派生类也一样。

如果游戏版本升级，增加了新的怪物雷鸟CThunderBird，只需要编写心累CThunderBird，不需要在已有的类例专门为新怪物增加：

void Attack( CThunderBird * pThunderBird) ;

void FightBack( CThunderBird * pThunderBird) ;

第三节 多态实例：几何形体程序

几何形体处理程序：输入若干个几何形体的参数，要求按面积排序输出，输出时要指明形状。

输入：

第一行是几何体数目n（不超过100行），下面有n行，每行以一个字母开头：

（1）若字母为“R”，则代表一个矩形，本行后面跟着两个整数，分别是矩形的宽和高；

（2）若字母为“C”，则代表一个圆，本行后面跟着一个整数代表其半径；

（3）若字母为“T”，则代表一个三角形，本行后面跟着三个整数，代表三条边的长度。

输出：

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

形体名称：面积

代码如下：

#include <iostream>

#include <stdlib.h>

#include <math.h>

using namespace std;

class CShape {

public:

virtual double Area() = 0;//纯虚函数

virtual void PrintInfo() = 0;

};

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];//基类指针，可以指向不同派生类

int MyCompare(const void *s1, const void*s2);

int main() {

int i, 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 (int i = 0; i < n; i++)

pShapes[i]->PrintInfo();//利用多态操作不同类的输出函数

system(“pause”);

return 0;

}

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;

a1 = (*p1)->Area();

a2 = (*p2)->Area();

if (a1 < a2)

return  -1;

else if (a2 < a1)

return 1;

else

return 0;

}

因为s1和s2都是void*，所以没办法直接获取到指向的内容。所以设置了两个CShape**的变量p1和p2，把s1和s2强制转换成CShape**类型。s1和s2是指向pShapes数组中的元素，数组元素类型为CShape*。p1，p2是指向指针的指针，所以要用两个*。

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

又一个例子，还是比较好理解的：

图3.1 多态又一例子

在非构造函数、非析构函数的成员函数中调用虚函数，是多态。

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

派生类中和基类中虚函数同名同参数表的函数，不加virtual也自动成为虚函数。

图3.2 虚函数访问权限介绍

在这里会出现编译出错。因为语法检查是不考虑运行结果，所以在fun2()是Base的私有成员的时候，语法检查直接给判错，即便运行到此时实际上按照规定是调用的Derived的公有成员fun2()。

但是如果基类中是public，派生类中即使是private，编译依然能通过，因为语法检查还是只看能不能访问基类的，运行的时候再看实际情况。这里面因为基类指针指向了派生类，所以派生类中成员函数是private也是可以运行出来的。

第四节 多态的实现原理

“多态”的关键在于通过基类指针或引用调用一个虚函数时，编译时不确定到底调用的是基类还是派生类的函数，运行时才确定——这叫“动态联编”。当然多态就是在运行的时候才确定调用谁的函数，而不是在编译的时候确定。

例程如下：

class Base{

public:

int i;

virtual void Print(){cout << “Base Print”<<endl;}

};

class Derived:public Base{

public:

int n;

virtual void Print){cout<<“Derived Print”<<endl;}

};

int main(){

Derived d;

cout<<sizeof(Base)<<sizeof(Derived);

return 0;

}

输出结果本来我们认为是4和8，但实际上却是8和12，这是为什么呢？

1.多态实现的关键——虚函数表

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

图4.1 Base类的虚函数表

图4.2 Deriverd类的虚函数表

    多态程序会有额外的时间（查询函数表）和空间开销（虚函数表）。

又一个例程：

#include <iostream>

using namespace std;

class A{

public:virtual void Func(){cout <<“A::Func””<<endl;}

};

class B: public A{

public:virtual void Func(){cout<<“B::Func”<<endl;}

};

int main(){

A a;

A* pa = new B();

pa->Func();//显然，输出结果为B::Func

//在64位电脑执行，64位程序指针为8字节

long long *p1 = (long long *)&a;//把a的地址转换成一个longlong型的地址指针赋值给p1

long long *p2 = (long long *)pa;//把new出来的B的地址转换成longlong型的地址指针赋给p2

*p2 = *p1;//=是赋值号。把p1指向地方的内容放在p2指向的地方去。

//由于p1是longlong型，所以*p1是8字节的内容。8个地址正好也是一个地址，这个地址放在a对象的开头，是classA的虚函数表的地址。

//p2指向New出来的B对象，所以p2的开头也应该放着classB的虚函数表的地址，也是8个字节。

//把p1指向的8个字节赋值给了p2指向的8个字节，所以下面语句输出值为A::Func

pa->Func();

return 0;

}

第五节 虚析构函数、纯虚函数和抽象类

1.虚析构函数（不是多态）

通过基类的指针删除派生类对象时，通常情况下只调用基类的析构函数。但是，删除一个派生类的对象时，应该先调用派生类的析构函数，然后调用基类的析构函数。

解决方法：把基类的析构函数声明为virtual。

派生类的析构函数可以不进行声明也是虚函数。通过基类的指针删除派生类对象时，首先调用派生类的析构函数，然后调用基类的析构函数。

一般来说，一个类如果定义了虚函数，则应该将析构函数也定义成虚函数。或者，一个类打算作为基类使用，也应该将析构函数定义成虚函数。

注意：不允许以虚函数作为构造函数。

例子：

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

2.纯虚函数和抽象类

纯虚函数：没有函数体的虚函数，不等同于函数体无语句！！！。

格式如下：

virtual void Print( )=0;//纯虚函数

包含纯虚函数的类叫抽象类。抽象类只能作为基类来派生新类使用，不能创建抽象类的对象；抽象类的指针和引用可以指向由抽象类派生出来的类的对象。

如下例：

A a ; // 错，A 是抽象类，不能创建对象

A * pa ; // ok,可以定义抽象类的指针和引用

pa = new A ; //错误, A 是抽象类，不能创建对象

在抽象类的成员函数内可以调用纯虚函数，但是在构造函数或析构函数内部不能调用纯虚函数。

如果一个类从抽象类派生而来，那么当且仅当它实现了基类中的所有纯虚函数，它才能成为非抽象类。

例程：

class A{

public:

virtual void f() =0;//纯虚函数

void g(){this->f();//ok

}

A(){//f();//错误

}

};

class B:public A{

public:

void f(){cout<<“B:f()”<<endl;}

};

int main(){

B b;

b.g();

return 0;

}

输出：B.f()