C++面向对象程序设计课程笔记（第六周）
第六周：多态
第一节 虚函数和多态的基本概念
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()
