C++期末模拟

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;// 输入数据，创建普通会员对象mmcin >> bn >> name >> jn;Member mm(bn, name, jn);// 使用指针pm执行以下操作：// 1、pm指向普通会员对象mmpm = &mm;// 2、输入数据，通过pm执行积分累加和积分兑换cin >> money >> num;pm->add(money);pm->exchange(num);// 3、通过pm调用打印方法输出pm->print();// 输入数据，创建贵宾会员对象vvcin >> bn >> name >> jn >> lpro >> dpro;;VIP vv(bn, name, jn, lpro, dpro);// 使用指针pm执行以下操作：// 1、pm指向贵宾会员对象vvpm = &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和kindCN cn(0, 0, 0, 0, "中国计重");cin >> tw;cn.Convert(tw); // 把输入的克数转成中国计重cout << cn;// 创建英国计重类对象en// 构造参数对应磅、盎司、打兰、克、类型，其中克和类型是对应基类属性gram和kindEN 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和kindCN cn(0, 0, 0, 0, "中国计重");cin >> tw;cn.Convert(tw); // 把输入的克数转成中国计重cout << cn;// 创建英国计重类对象en// 构造参数对应磅、盎司、打兰、克、类型，其中克和类型是对应基类属性gram和kindEN en(0, 0, 0, 0, "英国计重");cin >> tw;en.Convert(tw); // 把输入的克数转成英国计重cout << en;cn = en; // 把英国计重转成中国计重cout << cn;return 0;
}