id:124 A. 一、会员积分（期末模拟）
题目描述
某电商网站的会员分为：普通、贵宾两个级别
普通会员类Member，包含编号、姓名、积分三个属性，编号和积分是整数，姓名是字符串
操作包括构造、打印、积分累加、积分兑换，操作定义如下：
- 积分累加add，是根据消费金额累加积分，无返回值，参数是消费金额（整数），积分根据消费金额按1比1的比例累加。
- 积分兑换exchange，是按照每100积分换1元的比例，把积分兑换成现金。参数是要兑换的积分数量，返回值是兑换的现金数量。
注意：兑换积分数量不足100的部分是不能兑换的，例如会员原有500积分，要兑换积分数量为450，则450/100=4，最终用400积分兑换4元，会员余100积分。 - 打印是输出会员信息，格式参考输出样例
贵宾会员类VIP，继承了普通会员的属性与操作，新增两个属性：累加比例(整数)、兑换比例(整数)。并且重定义了所有操作：
- 积分累加中，积分按累加比例进行累加。例如累加比例是2，消费金额100元，则累加积分=100*2=200
- 积分兑换中，按照兑换比例的数值把积分抵扣消费金额。例如兑换比例是90，会员原有500积分，要兑换积分数量为420，则420/90=4，最终用360积分兑换4元，会员余140积分。
- 打印是输出会员信息，格式参考输出样例
程序要求
- 采用继承机制实现上述会员关系
- 打印、积分累加和积分兑换都采用虚函数方式，来实现运行多态性
- 派生的构造函数必须考虑基类属性的构造。
- 必须采用以下代码框架，在提示的地方增加代码，其他地方不能修改。
上述所有类属性都不是public，用面向对象思想和C++语言实现上述要求
----参考代码----
// 普通会员类
class Member
{
// ....代码自行编写
};
// 贵宾会员类
class VIP ....
{
// ....代码自行编写
};
int main()
{
// 创建一个基类对象指针
Member* pm;
// ....其他变量自行编写
// 输入数据，创建普通会员对象mm
// 使用指针pm执行以下操作：
// 1、pm指向普通会员对象mm
// 2、输入数据，通过pm执行积分累加和积分兑换
// 3、通过pm调用打印方法输出
// 输入数据，创建贵宾会员对象vv
// 使用指针pm执行以下操作：
// 1、pm指向贵宾会员对象vv
// 2、输入数据，通过pm执行积分累加和积分兑换
// 3、通过pm调用打印方法输出
return 0;
}
输入
第一行输入普通会员的三个信息：编号、姓名、积分
第二行输入两个操作信息：消费金额、积分兑换数量，表示普通会员执行一次积分累加，一次积分兑换
第三行输入贵宾会员的五个信息：编号、姓名、积分、累加比例、兑换比例
第四行输入两个操作信息：消费金额、积分兑换数量，表示贵宾会员执行一次积分累加，一次积分兑换
输出
第一行输出普通会员执行两个操作后的信息，要求调用打印方法
第二行输出贵宾会员执行两个操作后的信息，要求调用打印方法
输入样例
1001 John 500
244 300
8001 Jane 300 2 90
100 420
输出样例
普通会员1001–John–444
贵宾会员8001–Jane–140
题解
- 本题使用到的知识点有继承，虚函数与多态
- 首先看
Member类的实现，此类里面实现了构造，打印，积分累加和积分兑换，最后三个都是虚函数，因为其的子类也需要实现这三个函数 - 类
VIP继承了Member类，实现的功能有构造，打印，积分累加和积分兑换 - 虚函数的主要目的是，在主函数中定义一个父类的指针，两个类的类型的变量，通过父类的指针指向不同类类型的变量从而调用不同类的类函数，如果不使用虚函数的话，不管主函数中的父类指针指向哪个变量，最终都会调用父类的函数，因为这是静态联编的作用，虚函数的目的是实现动态联编
代码实现
#include <iostream>
using namespace std;
class Member
{
protected:
int b_num, j_num;
string name;
public:
Member(int b, string n, int j);
virtual void print();
virtual void add(int m);
virtual int exchange(int n);
};
Member::Member(int b, string n, int j)
: b_num(b), j_num(j), name(n)
{
}
void Member::print()
{
cout << "普通会员" << b_num << "--" << name << "--" << j_num << endl;
}
void Member::add(int m)
{
j_num += m;
}
int Member::exchange(int n)
{
j_num -= (n / 100) * 100;
return n / 100;
}
class VIP : public Member
{
private:
int l_pro, d_pro;
public:
VIP(int b, string n, int j, int l, int d);
void print();
void add(int m);
int exchange(int n);
};
VIP::VIP(int b, string n, int j, int l, int d)
: Member(b, n, j), l_pro(l), d_pro(d)
{
}
void VIP::print()
{
cout << "贵宾会员" << b_num << "--" << name << "--" << j_num << endl;
}
void VIP::add(int m)
{
j_num += l_pro * m;
}
int VIP::exchange(int n)
{
j_num -= (n / d_pro) * d_pro;
return n / d_pro;
}
int main()
{
int bn, jn, money, num, lpro, dpro;
string name;
// 创建一个基类对象指针
Member * pm;
// 输入数据，创建普通会员对象mm
cin >> bn >> name >> jn;
Member mm(bn, name, jn);
// 使用指针pm执行以下操作：
// 1、pm指向普通会员对象mm
pm = &mm;
// 2、输入数据，通过pm执行积分累加和积分兑换
cin >> money >> num;
pm->add(money);
pm->exchange(num);
// 3、通过pm调用打印方法输出
pm->print();
// 输入数据，创建贵宾会员对象vv
cin >> bn >> name >> jn >> lpro >> dpro;;
VIP vv(bn, name, jn, lpro, dpro);
// 使用指针pm执行以下操作：
// 1、pm指向贵宾会员对象vv
pm = &vv;
// 2、输入数据，通过pm执行积分累加和积分兑换
cin >> money >> num;
pm->add(money);
pm->exchange(num);
// 3、通过pm调用打印方法输出
pm->print();
return 0;
}
id:125 B. 二、金属加工（期末模拟）
题目描述
在金属加工中，金属具有硬度、重量、体积的属性（都是整数），包括四种操作：
- 合并，每两块金属可以合并成一块新的金属。新金属的重量等于原两块金属的重量之和，体积和硬度也类似计算。
- 巨化，金属通过熔炼风吹的方法会巨化，体积变大n倍，重量和硬度不变
- 硬化，在金属中加入高分子材料可以硬化金属，每提升硬度一级，重量和体积都增加10%。
- 软化，在金属中加入特殊化学溶液可以降低金属硬度，每降低硬度一级，重量和体积都减少10%
用类来描述金属，用运算符重载方式实现金属的四种操作，并定义打印函数，具体要求如下
- 用加法运算符、友元的方式实现合并
- 用乘法运算符、友元的方式实现巨化，含两个参数：金属对象、巨化倍数
- 用++运算符、成员函数、前增量的方式实现硬化
- 用–运算符、成员函数、后增量的方式实现软化
- 打印函数用来输出金属的信息，输出格式看参考样本
操作中所有属性的运算结果都只保留整数部分。
上述所有类属性都不是public，用面向对象思想和C++语言实现上述要求
输入
第一行输入第一块金属的信息，包括硬度、重量、体积
第二行输入第二块金属的信息，包括硬度、重量、体积
第三行输入一个参数n，表示巨化n倍
输出
第一行输出两块金属合并后的信息
第二行输出第一块金属巨化n倍的信息
第三行输出第一块金属提升硬度一级后的信息
第四行输出第二块金属降低硬度一级后的信息
输入样例
3 3000 300
5 5000 500
2
输出样例
硬度8–重量8000–体积800
硬度3–重量3000–体积600
硬度4–重量3300–体积330
硬度4–重量4500–体积450
题解
- 此题运用到的知识点为类，友元和运算符重载
- 首先看
CMetal类的实现，实现的功能有有参和无参的构造，运用友元实现运算符+和*的重载，用成员函数实现++，--和=的重载，还有打印函数 - 需要注意的是
CMetal& operator++();这个形式表示的是前增量，CMetal operator--(int);是后增量，CMetal& operator=(const CMetal& m1);，返回一个引用的形式的话不能返回一个临时变量，一般是返回他自己，即*this
代码实现
#include <iostream>
using namespace std;
class CMetal
{
private:
int hard, w, v;
public:
CMetal();
CMetal(int h1, int w1, int v1);
friend CMetal operator+(const CMetal& m1, const CMetal& m2);
friend CMetal operator*(const CMetal& m1, int n);
CMetal& operator++(); // 前增量
CMetal operator--(int); // 后增量
CMetal& operator=(const CMetal& m1);
void print();
};
CMetal::CMetal()
: hard(0), w(0), v(0)
{
}
CMetal::CMetal(int h1, int w1, int v1)
: hard(h1), w(w1), v(v1)
{
}
CMetal operator+(const CMetal& m1, const CMetal& m2)
{
CMetal mm;
mm.hard = m1.hard + m2.hard;
mm.w = m1.w + m2.w;
mm.v = m1.v + m2.v;
return mm;
}
CMetal operator*(const CMetal& m1, int n)
{
CMetal mm;
mm.hard = m1.hard;
mm.w = m1.w;
mm.v = m1.v * n;
return mm;
}
CMetal& CMetal::operator++()
{
hard++;
w += w * 0.1;
v += v * 0.1;
return *this;
}
CMetal CMetal::operator--(int)
{
CMetal temp(*this); // 把自己拷贝
hard--;
w -= w * 0.1;
v -= v * 0.1;
return temp;
}
CMetal& CMetal::operator=(const CMetal& m1)
{
hard = m1.hard;
w = m1.w;
v = m1.v;
return *this;
}
void CMetal::print()
{
cout << "硬度" << hard << "--重量" << w << "--体积" << v << endl;
}
int main()
{
int h1, w1, v1, h2, w2, v2, n;
cin >> h1 >> w1 >> v1 >> h2 >> w2 >> v2 >> n;
CMetal m1(h1, w1, v1);
CMetal m2(h2, w2, v2);
CMetal m3;
m3 = m1 + m2; // 合并
m3.print();
m3 = m1 * n; // 巨化
m3.print();
++m1; // 提升硬度一级
m1.print();
m2--; // 降低硬度一级
m2.print();
return 0;
}
id:126 C. 三、加密模板（期末模拟）
题目描述
加密机制包括明文、密文、密钥。用密钥对明文进行加密后就得到密文。
在古典加密机制中，偏离值是一种常见的方法，加密过程为
- 在已知数据中找出最大值
- 用最大值减去各个数值，得到相应的偏离值
- 偏离值加上密钥就得到密文
例如明文为1 2 3 4 5，密钥是10，加密过程为： - 找出明文的最大值是5
2、用5减去明文的各个数值，得到偏离值4 3 2 1 0 - 用偏离值加上密钥，得到密文14 13 12 11 10
定义一个函数模板，名为max，参数包括数组和数组长度，返回值是数组中的最大值，要求支持整数、浮点数和字符三种类型。
用类模板定义一个加密类，包含四个属性：明文、密文、密钥、长度，前三个属性都是同一种类型，长度是整数。长度是指明文的长度。
类模板包含操作构造、加密、打印，说明如下：
- 加密是调用函数模板max得到数组最大值，按照前面的方法使用最大值和密钥进行加密，得到密文
- 打印是输出密文
要求类模板支持整数、浮点数和字符三种类型。
参考代码给出了加密类界面（只支持整数类型）、主函数（支持三种数据类型），程序要求
- 根据要求编写函数模板max
- 使用类模板方法改造加密类界面，不能增加任何属性和操作，必须在类外实现构造函数和加密方法
- 主函数不能有任何修改
上述所有类属性都不是public，用面向对象思想和C++语言实现上述要求
----参考代码----
//只支持整数类型的加密类界面
class Cryption
{
private:
int ptxt[100]; //明文
int ctxt[100]; //密文
int key; //密钥
int len; //长度
public:
Cryption(int tk, int tt[], int n); //参数依次对应密钥、明文、长度
void encrypt(); //加密
void print() //打印，无需改造
{
int i;
for (i = 0; i < len - 1; i++)
{
cout << ctxt[i] << " ";
}
cout << ctxt[i] << endl;
}
};
//支持三种类型的主函数
int main()
{
int i;
int length; //长度
int ik, itxt[100];
double dk, dtxt[100];
char ck, ctxt[100];
//整数加密
cin >> ik >> length;
for (i = 0; i < length; i++)
{
cin >> itxt[i];
}
Cryption<int> ic(ik, itxt, length);
ic.encrypt();
ic.print();
//浮点数加密
cin >> dk >> length;
for (i = 0; i < length; i++)
{
cin >> dtxt[i];
}
Cryption<double> dc(dk, dtxt, length);
dc.encrypt();
dc.print();
//字符加密
cin >> ck >> length;
for (i = 0; i < length; i++)
{
cin >> ctxt[i];
}
Cryption<char> cc(ck, ctxt, length);
cc.encrypt();
cc.print();
return 0;
}
输入
第一行输入整数类型的信息，包括密钥、长度、明文
第二行输入浮点数类型的信息，包括密钥、长度、明文
第三行输入字符类型的信息，包括密钥、长度、明文
输出
三行分别输出三种类型的密文
输入样例
10 5 1 2 3 4 5
11.11 4 1.1 2.2 3.3 4.4
O 3 a b c
输出样例
14 13 12 11 10
14.41 13.31 12.21 11.11
Q P O
题解
- 本体用到的知识点是类的模板和函数模板
- 在主函数中定义类的一个变量时，需要用<>，在尖括号里面写出这个变量的类型，例如
Cryption<int> ic(ik, itxt, length);
代码实现
#include <iostream>
using namespace std;
template <typename T1>
T1 Max(int n, T1* a)
{
int i;
T1 max = a[0];
for (i = 0; i < n; i++)
{
if (a[i] > max)
{
max = a[i];
}
}
return max;
}
template <typename T1>
class Cryption
{
private:
int len; // 长度是指明文的长度
T1 ptxt[100], ctxt[100], key; // 明文，密文，密钥
public:
Cryption(T1 tk, T1 tt[], int n); //参数依次对应密钥、明文、长度
void encrypt(); //加密
void print(); //打印
};
template <typename T1>
Cryption<T1>::Cryption(T1 tk, T1 tt[], int n)
: len(n), key(tk)
{
int i;
for (i = 0; i < len; i++)
{
ptxt[i] = tt[i];
ctxt[i] = 0;
}
}
template <typename T1>
void Cryption<T1>::encrypt() // 加密
{
int i;
T1 max = Max(len, ptxt);
for (i = 0; i < len; i++)
{
ctxt[i] = (max - ptxt[i]) + key;
}
}
template <typename T1>
void Cryption<T1>::print()
{
int i;
for (i = 0; i < len - 1; i++)
{
cout << ctxt[i] << " ";
}
cout << ctxt[i] << endl;
}
int main()
{
int i;
int length; //长度
int ik, itxt[100];
double dk, dtxt[100];
char ck, ctxt[100];
//整数加密
cin >> ik >> length;
for (i = 0; i < length; i++)
{
cin >> itxt[i];
}
Cryption<int> ic(ik, itxt, length);
ic.encrypt();
ic.print();
//浮点数加密
cin >> dk >> length;
for (i = 0; i < length; i++)
{
cin >> dtxt[i];
}
Cryption<double> dc(dk, dtxt, length);
dc.encrypt();
dc.print();
//字符加密
cin >> ck >> length;
for (i = 0; i < length; i++)
{
cin >> ctxt[i];
}
Cryption<char> cc(ck, ctxt, length);
cc.encrypt();
cc.print();
return 0;
}
id:127 D. 四、加湿风扇（期末模拟）
题目描述
已知家电有编号、功率的属性，属性都是整数，操作包括构造和打印等
电风扇继承家电的特点，新增两个属性（整数）：风向和风力，其中风向为0表示定向吹风，状态为1表示旋转吹风。
风扇包含两个新操作：风向控制和风力控制
- 风向控制含一个整数参数，无返回，把风向设置为参数值，参数为0表示定向吹风，为1表示旋转吹风。
- 风力控制含一个整数参数，无返回，把风力设置为参数值，参数表示风力级别，例如1级、2级、3级等。
加湿器继承家电的特点，新增两个属性（浮点数）：实际水容量和最大水容量
新增操作是预警，无参数，返回值为整数，当实际水容量不小于最大水容量的50%，则返回1；小于50%且不小于10%则返回2，小于10%则返回3
加湿风扇继承了风扇和加湿器的特点，新增属性档位（整数）
新增操作调整档位，含一个参数，无返回值，先设置档位为参数值，再调用风向控制和风力控制来设置相关属性，包括：
- 参数为0，不做其他属性修改
- 参数为1，设置定向吹风且风力1级
- 参数为2，设置旋转吹风且风力2级
- 参数为3，设置旋转吹风且风力3级
档位只可能是0、1、2、3四个数值，其他数值忽略。
加湿风扇重载打印操作，输出格式参考样本。输出要求如下： - 如果风向为0，则输出定向吹风，风向为1则输出旋转吹风。
- 调用预警操作，并根据返回结果1、2、3输出不同信息，分别是：水量正常、水量偏低、水量不足
程序要求
- 采用虚拟继承机制实现上述电器的关系，明确谁是虚基类、基类、派生类
- 基类和派生类的构造要考虑虚基类、基类的属性构造
上述所有类属性都不是public，用面向对象思想和C++语言实现上述要求
输入
第一行输入t，表示有t个实例
第二行输入一个加湿风扇的信息，依次包括编号、功率、风向、风力、实际水容量、最大水容量 档位
第三行输入一个参数，表示调档操作的档位，然后执行调档操作。
以此类推，输入t个实例
输出
对于每个实例，调用打印操作输出加湿风扇的最终状态
输入样例
3
1001 1000 1 2 3 4 0
1
2002 2000 0 1 1 12 0
3
3003 3000 0 3 2 10 0
0
输出样例
加湿风扇–档位1
编号1001–功率1000W
定向吹风–风力1级
实际水容量3升–水量正常
加湿风扇–档位3
编号2002–功率2000W
旋转吹风–风力3级
实际水容量1升–水量不足
加湿风扇–档位0
编号3003–功率3000W
定向吹风–风力3级
实际水容量2升–水量偏低
题解
- 本题运用到的知识点有菱形继承，虚继承，虚函数
- 虚继承适用于菱形继承的情况
代码实现
#include <iostream>
using namespace std;
class CHome
{
private:
int num, p;
public:
CHome(int n, int p1);
virtual void print();
};
CHome::CHome(int n, int p1)
: num(n), p(p1)
{
}
void CHome::print()
{
cout << "编号" << num << "--功率" << p << "W" << endl;
}
class CFan : virtual public CHome
{
protected:
int dir, fo;
public:
CFan(int n, int p, int d, int f);
void setD(int x); // 风向控制
void setF(int x); // 风力控制
};
CFan::CFan(int n, int p, int d, int f)
: CHome(n, p), dir(d), fo(f)
{
}
void CFan::setD(int x)
{
dir = x; // 参数为0表示定向吹风，为1表示旋转吹风
}
void CFan::setF(int x)
{
fo = x;
}
class CAdd : virtual public CHome
{
protected:
double v, maxv;
public:
CAdd(int n, int p, double v1, double m);
int warn();
};
CAdd::CAdd(int n, int p, double v1, double m)
: CHome(n, p), v(v1), maxv(m)
{
}
int CAdd::warn()
{
if (v >= maxv * 0.5) // 实际水容量不小于最大水容量的50%
{
return 1;
}
else if (v < maxv * 0.5 && v >= maxv * 0.1)
{
return 2;
}
else if (v < maxv * 0.1)
{
return 3;
}
}
class Caddfan : public CFan, public CAdd
{
private:
int dnum;
public:
Caddfan(int n, int p, int dir, int f, double v, double m, int d);
void adjust(int n);
void print();
};
Caddfan::Caddfan(int n, int p, int dir, int f, double v, double m, int d)
: CHome(n, p), CFan(n, p, dir, f), CAdd(n, p, v, m), dnum(d)
{
}
void Caddfan::adjust(int n)
{
dnum = n;
if (dnum == 1) // 设置定向吹风且风力1级
{
setD(0);
setF(1);
}
else if (dnum == 2) // 设置旋转吹风且风力2级
{
setD(1);
setF(2);
}
else if (dnum == 3) // 设置旋转吹风且风力3级
{
setD(1);
setF(3);
}
}
void Caddfan::print()
{
cout << "加湿风扇--档位" << dnum << endl;
CHome::print();
if (dir == 0)
{
cout << "定向吹风--风力";
}
else if (dir == 1)
{
cout << "旋转吹风--风力";
}
cout << fo << "级" << endl;
cout << "实际水容量" << v << "升--";
if (warn() == 1)
{
cout << "水量正常" << endl;
}
else if (warn() == 2)
{
cout << "水量偏低" << endl;
}
else
{
cout << "水量不足" << endl;
}
}
int main()
{
int t, i, num, p, dir, fo, d, dd;
double v, maxv;
CHome* hm;
cin >> t;
for (i = 0; i < t; i++)
{
cin >> num >> p >> dir >> fo >> v >> maxv >> d >> dd;
Caddfan af1(num, p, dir, fo, v, maxv, d);
af1.adjust(dd);
hm = &af1;
hm->print();
}
return 0;
}
id:128 E. 五、计重转换（期末模拟）
题目描述
目前国际计重最基本的单位是克。在古代各个国家的计重单位是不同的。
中国使用斤、两、钱来表示重量，其中1斤=10两，1两=10钱
中国计重单位与克的关系为：1斤=500克，1两=50克，1钱=5克
英国使用磅、盎司、打兰来表示重量，其中1磅=16盎司，1盎司=16打兰
英国计重单位与克的关系为：1磅=512克，1盎司=32克，1打兰=2克
以下参考代码包含了抽象类Weight，中国计重和英国计重都继承了抽象类。
中国计重类新增了斤、两、钱三个属性，并新增了一个操作：计重转换Convert。
Convert能够把输入的克数转成中国计重，例如1234克转成2斤4两6钱4克，并且把数值放入斤、两、钱、克四个属性中
英国计重类新增了磅、盎司、打兰三个属性，并新增了两个操作：
- 计重转换Convert，功能与上述类似，例如2345克转成4磅9盎司4打兰1克，并且把数值放入对应的四个属性中
- 计重等价，重载类型转换运算符，实现将英国计重类的对象转换成中国计重类的对象，例如英国计重类对象en（2磅2盎司11打兰1克）等价于（转换成）中国计重类对象cn（2斤2两2钱1克）。
程序要求如下
- 参考代码框架不能做任何修改，在要求的地方添加代码
- 主函数不能有任何修改
以上数据纯粹为题目设计，方便计算，实际换算数据是不同的。
上述所有类属性都不是public，用面向对象思想和C++语言实现上述要求
----参考代码----
class CN; //提前声明
class EN; //提前声明
// 抽象类
class Weight
{
protected:
char kind[20]; //计重类型
int gram; // 克
public:
Weight(const char tk[] = "no name", int tg = 0)
{
strcpy(kind, tk);
gram = tg;
}
virtual void print(ostream& out) = 0; // 输出不同类型的计重信息
};
// 中国计重
class CN : public Weight
{
// ....类定义自行编写
};
// 英国计重
class EN : public Weight
{
// ....类定义自行编写
};
// 以全局函数方式重载输出运算符，代码3-5行....自行编写
// 重载函数包含两个参数：ostream流对象、Weight类对象，参数可以是对象或对象引用
// 重载函数必须调用参数Weight对象的print方法
// 主函数
int main()
{
int tw;
// 创建一个中国计重类对象cn
// 构造参数对应斤、两、钱、克、类型，其中克和类型是对应基类属性gram和kind
CN cn(0, 0, 0, 0, "中国计重");
cin >> tw;
cn.Convert(tw); // 把输入的克数转成中国计重
cout << cn;
// 创建英国计重类对象en
// 构造参数对应磅、盎司、打兰、克、类型，其中克和类型是对应基类属性gram和kind
EN en(0, 0, 0, 0, "英国计重");
cin >> tw;
en.Convert(tw); // 把输入的克数转成英国计重
cout << en;
cn = en; // 把英国计重转成中国计重
cout << cn;
return 0;
}
输入
第一行输入一个克数，调用中国计重转换，把克数转成中国计重
第二行输入一个克数，调用英国计重转换，把克数转成英国计重，并调用计重等价把英国计重转成中国计重
输出
根据主函数运行输出
输入样例
1234
2345
输出样例
中国计重:2斤4两6钱4克
英国计重:4磅9盎司4打兰1克
中国计重:4斤6两9钱0克
题解
- 主要用到的知识点是继承，虚函数，输出运算符重载
- 注意一下计算即可
代码实现
#include <iostream>
#include <cstring>
using namespace std;
class CN; // 提前声明
class EN; // 提前声明
// 抽象类
class Weight
{
protected:
char kind[20]; // 计重类型
int gram; // 克
public:
Weight(const char tk[] = "no name", int tg = 0);
virtual void print(ostream& out) = 0; // 输出不同类型的计重信息
};
Weight::Weight(const char tk[], int tg)
{
strcpy(kind, tk);
gram = tg;
}
class EN : public Weight
{
private:
int pound, ounce, dram;
public:
EN(int p, int o, int d, int g, const char* k);
void Convert(int g);
void print(ostream& out);
friend ostream& operator<<(ostream&, const Weight&);
friend class CN;
};
EN::EN(int p, int o, int d, int g, const char* k)
: Weight(k, g), pound(p), ounce(o), dram(d)
{
}
void EN::Convert(int g)
{
pound = g / 512;
g -= pound * 512;
ounce = g / 32;
g -= ounce * 32;
dram = g / 2;
g -= dram * 2;
gram = g;
}
void EN::print(ostream& out)
{
out << kind << ":" << pound << "磅" << ounce << "盎司" << dram << "打兰" << gram << "克" << endl;
}
class CN : public Weight
{
private:
int jin, liang, money;
public:
CN(int j, int l, int m, int g, const char* k);
void Convert(int g);
void print(ostream& out);
CN& operator=(const EN& e1);
friend ostream& operator<<(ostream&, const Weight&);
};
CN::CN(int j, int l, int m, int g, const char* k)
: Weight(k, g), jin(j), liang(l), money(m)
{
}
void CN::Convert(int g)
{
jin = g / 500;
g -= jin * 500;
liang = g / 50;
g -= liang * 50;
money = g / 5;
g -= money * 5;
gram = g;
}
void CN::print(ostream& out)
{
out << kind << ":" << jin << "斤" << liang << "两" << money << "钱" << gram << "克" << endl;
}
CN& CN::operator=(const EN& e1)
{
gram = e1.pound * 512 + e1.ounce * 32 + e1.dram * 2 + e1.gram;
jin = gram / 500;
gram -= jin * 500;
liang = gram / 50;
gram -= liang * 50;
money = gram / 5;
gram -= money * 5;
return *this;
}
// 以全局函数方式重载输出运算符，代码3-5行....自行编写
// 重载函数包含两个参数：ostream流对象、Weight类对象，参数可以是对象或对象引用
// 重载函数必须调用参数Weight对象的print方法
ostream& operator<<(ostream& o, Weight& w)
{
w.print(o);
return o;
}
int main()
{
int tw;
// 创建一个中国计重类对象cn
// 构造参数对应斤、两、钱、克、类型，其中克和类型是对应基类属性gram和kind
CN cn(0, 0, 0, 0, "中国计重");
cin >> tw;
cn.Convert(tw); // 把输入的克数转成中国计重
cout << cn;
// 创建英国计重类对象en
// 构造参数对应磅、盎司、打兰、克、类型，其中克和类型是对应基类属性gram和kind
EN en(0, 0, 0, 0, "英国计重");
cin >> tw;
en.Convert(tw); // 把输入的克数转成英国计重
cout << en;
cn = en; // 把英国计重转成中国计重
cout << cn;
return 0;
}
