（一三八）多态公有继承-CSDN博客

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

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

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

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

②使用虚方法。

注：这两种机制共同使用

虚方法的关键字是：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]，使用虚方法，就可以展现出不同类型的结果（原因在于虚方法是根据指针指向的对象的类型决定调用哪一个，而不是根据指针的类型）。