第六周:多态

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

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