（一三八）多态公有继承

假如一个类继承另一个类，但有一个类方法，在不同类中，其行为是不同的。

换句话说，方法的行为，应取决于调用该方法的对象。这种较复杂的行为称为 多态——具有多种形态，即同一种方法的行为，随上下文而异。

有两种重要的机制可用于实现多态公有继承：

①在派生类中重新定义基类的方法；

②使用虚方法。

注：这两种机制共同使用

虚方法的关键字是：virtual

例如：virtual void show();

虚方法的关键字，不在类外部使用，例如.cpp文件中的方法定义

虚方法的作用在于：

在基类和派生类都有同名函数时，决定使用哪个类的方法，不是取决于指针/引用类型，而是取决于他们指向的对象的类型。

解释①：如果不是指针、引用，而是对象，那么根据对象类型决定，虚方法无影响；

解释②：因为基类的指针、引用，可以指向派生类对象；

解释③：假如不使用虚方法，决定使用哪一个方法，取决于指针/引用的类型，而不是取决于它们指向的类型（例如基类指针指向派生类，如果是非虚方法，则使用基类的方法；如果是虚方法，则使用派生类的方法）；

代码：

//1.h 基类和派生类声明
#pragma once
#include<iostream>
#include<string>
using std::string;

class Brass
{
string name;
int ID;
double money;
public:
Brass(string na = "None", int id = -1, double mo = 0);	//创建账户
bool Save(double mo);	//存款
virtual bool Load(double mo);	//取款
virtual void Show();	//显示账户信息
double Money() { return money; }	//返回当前存款
};

class Brass_plus :public Brass
{
double overdraft_Max;	//透支上限
double overdraft_Rate;	//透支贷款利率
double overdraft ;	//当前透支总额
public:
Brass_plus(const Brass& br,double ov_M = 500, double ov_R = 0.11125, double ov = 0);
bool ch_ov_M(double ov_M);	//设置透支上限
bool ch_ov_R(double ov_R);	//设置透支利率
virtual bool Load(double mo);	//取款，透支保护
virtual void Show();	//显示账号信息，更多
};
//2.cpp 基类和派生类的定义
#include"1.h"
using std::cout;
using std::endl;
using std::string;
typedef std::ios_base::fmtflags format;
typedef std::streamsize precis;	//这个不明白是什么意思
format setFormat();
void restore(format f, precis p);

Brass::Brass(string na, int id, double mo)
{
name = na;
ID = id;
money = mo;
}
bool Brass::Save(double mo)
{
if (mo < 0)
{
cout << "你不能存入小于0的金钱。" << endl;
return false;
}
else
{
money += mo;
cout << "存款成功。" << endl;
return true;
}
}
bool Brass::Load(double mo)
{
if (mo < 0)
{
cout << "你不能取出小于0的金钱。" << endl;
return false;
}
else if (mo>money)
{
cout << "余额不足。" << endl;
return false;
}
else
{
money -= mo;
cout << "取款成功。" << endl;
return true;
}
}
void Brass::Show()
{
cout << "姓名：" << name << "，存款账号：" << ID << "，账户余额：" << money << "元" << endl;
}
Brass_plus::Brass_plus(const Brass& br, double ov_M, double ov_R, double ov):Brass(br)
{
overdraft_Max = ov_M;
overdraft_Rate = ov_R;
overdraft = ov;
}
bool Brass_plus::ch_ov_M(double ov_M)	//设置透支上限
{
if (ov_M < 0)
{
cout << "设置失败，不能设置为负数。" << endl;
return false;
}
else
{
overdraft_Max = ov_M;
cout << "设置成功，新的透支上限为：" << overdraft_Max << "元" << endl;
return true;
}
}
bool Brass_plus::ch_ov_R(double ov_R)	//设置透支利率
{
if (ov_R < 0)
{
cout << "设置失败，不能设置为负数。" << endl;
return false;
}
else
{
overdraft_Rate = ov_R;
cout << "设置成功，新的利率为：" << overdraft_Rate * 100 << "%" << endl;
return true;
}
}
void Brass_plus::Show()	//显示账号信息，more
{
Brass::Show();
cout << "账户透支上限：" << overdraft_Max << " 元" << endl;
cout << "透支偿还利率：" << overdraft_Rate * 100 << " %" << endl;
cout << "当前透支额度为：" << overdraft << " 元" << endl;
}
bool Brass_plus::Load(double mo)	//取款，带有透支保护
{
format initialState = setFormat();	//这行貌似是存储输入状态（这个输入状态是函数的返回值）
precis prec = cout.precision(2);	//这行感觉是设置为两行输出

double MO = Brass::Money();
if (mo < 0||mo<MO)	//不涉及透支的取款
{
return Brass::Load(mo);
}
else if (mo>overdraft_Max - overdraft + MO)	//透支程度大于限额
{
cout << "超出限额，取款失败。" << endl;
return false;
}
else
{
Brass::Load(MO);	//先取光余额
overdraft += mo - MO;
cout << "取款成功，余额为：" << Brass::Money() << "，透支额为：" << overdraft << " 元，最大透支额为： " << overdraft_Max << "元" << endl;
return true;
}
restore(initialState, prec);	//这行好像是恢复
}

format setFormat()
{
return cout.setf(std::ios_base::fixed, std::ios_base::floatfield);
}
void restore(format f, precis p)
{
cout.setf(f, std::ios_base::floatfield);
cout.precision(p);
}
//1.cpp main函数测试用
#include<iostream>
#include"1.h"

int main()
{
using namespace std;
string name;
cout << "输入姓名：";
cin >> name;	//不能读取空格
cout << "输入ID编号（数字形式）：";
int ID;
cin >> ID;
cout << "输入存款金额：";
double money;
cin >> money;
Brass one(name, ID, money);
cout << "银行账户创建完毕。" << endl;
Brass_plus two(one);
cout << "已建立信用账号：" << endl;
double a;
cout << "s.存\tl.取.\tc.查询\tq.退出\n选择->";
char ch;
while (cin>>ch&&ch!='q')
{
cin.sync();
switch (ch)
{
case's':cout << "输入存款金额：";
cin >> a;
two.Save(a);
break;
case'l':cout << "输入取款金额：";
cin >> a;
two.Load(a);
break;
case'c':two.Show();
break;
default:cout << "输入错误。" << endl;
cin.clear();
cin.sync();
break;
}
cout << "s.存\tl.取.\tc.查询\tq.退出\n选择->";
}
cout << "设置利率（%）：";
double LiLv;
cin >> LiLv;
LiLv /= 100;
two.ch_ov_R(LiLv);
cout << "设置最大透支额度：";
double Max;
cin >> Max;
two.ch_ov_M(Max);
cout << "再次查看账户信息：";
two.Show();
cout << "Done." << endl;
system("pause");
return 0;
}

显示：

输入姓名：王冬
输入ID编号（数字形式）：12321
输入存款金额：1000
银行账户创建完毕。
已建立信用账号：
s.存    l.取.   c.查询  q.退出
选择->c
姓名：王冬，存款账号：12321，账户余额：1000元
账户透支上限：500 元
透支偿还利率：11.125 %
当前透支额度为：0 元
s.存    l.取.   c.查询  q.退出
选择->s
输入存款金额：400
存款成功。
s.存    l.取.   c.查询  q.退出
选择->c
姓名：王冬，存款账号：12321，账户余额：1400元
账户透支上限：500 元
透支偿还利率：11.125 %
当前透支额度为：0 元
s.存    l.取.   c.查询  q.退出
选择->l
输入取款金额：1500
取款成功。
取款成功，余额为：0.00，透支额为：100.00 元，最大透支额为： 500.00元
s.存    l.取.   c.查询  q.退出
选择->c
姓名：王冬，存款账号：12321，账户余额：0.00元
账户透支上限：500.00 元
透支偿还利率：11.13 %
当前透支额度为：100.00 元
s.存    l.取.   c.查询  q.退出
选择->l
输入取款金额：500
超出限额，取款失败。
s.存    l.取.   c.查询  q.退出
选择->q
设置利率（%）：15
设置成功，新的利率为：15.00%
设置最大透支额度：5000
设置成功，新的透支上限为：5000.00元
再次查看账户信息：姓名：王冬，存款账号：12321，账户余额：0.00元
账户透支上限：5000.00 元
透支偿还利率：15.00 %
当前透支额度为：100.00 元
Done.
请按任意键继续. . .

总结：

①派生类调用基类的公有方法，采用：基类名::基类方法 的形式。例如：

Brass::Show();

就是Brass_plus类的方法内，调用Brass类方法show()。

由于派生类和基类都有show()函数，假如不加类名。那么在派生类函数show()中使用show()，并不会调用基类的show()函数，反而会进入到无限递归之中。

②我在程序中，没有在透支时直接加上利息。原因在于，假如透支500元，加上利息后，实际需要偿还金额可能已经超过默认上限500元了，也就是超出透支额度。

③可以用指针数组。具体用法可以如下：

声明一个基类的指针数组：Brass people[4];

然后指针指向基类或者派生类，可以使用new来分配内存：

people[0]=new Brass(xxxxxxx);

people[1]=new Brass_plus(xxxx); //这个需要输入的内容更多，包括Brass类的数据成员

然后调用people[i]，使用虚方法，就可以展现出不同类型的结果（原因在于虚方法是根据指针指向的对象的类型决定调用哪一个，而不是根据指针的类型）。

关于虚函数的更多说明：

①当基类使用虚函数的时候，那么使用基类的指针/引用，将根据其指向的对象的类型决定使用哪个类的方法。

例如，基类的函数是自动继承到派生类的。如果派生类需要自定义使用某个基类的函数的实现，那么是可以直接在派生类中添加代码。

调用时，根据对象的类型决定调用哪个；

如果是指针，则根据指针的类型。——但若使用虚函数，这里则是根据指针指向的类型，即Brass类虚指针也可能使用Brass_plus类的方法。

②对于析构函数而言，派生类的对象调用析构函数时，则先调用派生类的析构函数，然后随之调用基类的虚构函数。

若使用基类的指针，那么基类的指针是可以指向派生类的对象的（前面说过）。

假如因为某种需要，基类的指针是new分配内存的派生类的对象（这是可以的），那么在delete的时候，也应该调用调用派生类的析构函数，再调用基类的析构函数。

然而，对于非虚函数而言，由于是基类的指针，因此直接调用了基类的析构函数，而没有调用派生类的析构函数。

但若基类的析构函数是虚函数。那么在调用时，则会根据指针或引用指向的对象，决定调用是基类还是派生类的析构函数。

基类指针被delete释放内存——》查看析构函数——》发现关键字virtual——》决定根据指针指向内容而决定使用哪个类方法。

也就是说，假如某个类是基类，那么最好给他的析构函数加上关键字virtual，让它成为一个虚析构函数。

③由此反推，假如某个类不会成为基类，那么它的函数就不需要加上关键字成为虚函数（即使他是某个基类的派生类），因为派生类的指针只能指向它自己，而不是指向基类（但基类指针可以指向派生类）。

但由于为了一目了然，因此，一般情况下，假如基类是虚函数，那么派生类也应该加上关键字 virtual 表示 有虚函数，以防混淆。