《C++面向对象程序设计》课程笔记 lessen6

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

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