A.一、会员积分（期末模拟）

题目描述

某电商网站的会员分为：普通、贵宾两个级别

普通会员类Member，包含编号、姓名、积分三个属性，编号和积分是整数，姓名是字符串
操作包括构造、打印、积分累加、积分兑换，操作定义如下：
1、积分累加add，是根据消费金额累加积分，无返回值，参数是消费金额（整数），积分根据消费金额按1比1的比例累加。
2、积分兑换exchange，是按照每100积分换1元的比例，把积分兑换成现金。参数是要兑换的积分数量，返回值是兑换的现金数量。
注意：兑换积分数量不足100的部分是不能兑换的，例如会员原有500积分，要兑换积分数量为450，则450/100=4，最终用400积分兑换4元，会员余100积分。
3、打印是输出会员信息，格式参考输出样例

贵宾会员类VIP，继承了普通会员的属性与操作，新增两个属性：累加比例(整数)、兑换比例(整数)。并且重定义了所有操作：
1、积分累加中，积分按累加比例进行累加。例如累加比例是2，消费金额100元，则累加积分=100*2=200
2、积分兑换中，按照兑换比例的数值把积分抵扣消费金额。例如兑换比例是90，会员原有500积分，要兑换积分数量为420，则420/90=4，最终用360积分兑换4元，会员余140积分。
3、打印是输出会员信息，格式参考输出样例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
#include<iostream>
using namespace std;

class Member
{
protected:
	int number;
	int points;
	string name;
public:
	Member(int num,int p,string na):number(num),points(p),name(na){}
	 virtual void add(int a);
	 virtual int exchange(int p);
	 virtual void print();
};

void Member::add(int a)
{
	points += a;
}

int Member::exchange(int p)
{
	int amount;
	if (p % 100 != 0)
	{
		p -= p % 100;
		points -= p;
		amount = p / 100;
	}
	else
	{
		points -= p;
		amount = p / 100;
	}
	return amount;
}

void Member::print()
{
	cout << "普通会员" << number << "--" << name << "--" << points << endl;
}

class Vip:public Member
{
protected:
	int add_page;
	int exchange_page;
public:
	Vip(int num, int p, string na, int ap, int ep) :Member(num, p, na)
	{
		add_page = ap;
		exchange_page = ep;
	}
	virtual void add(int a);
	virtual int exchange(int p);
	virtual void print();
};

void Vip::add(int a)
{
	int po;
	po = a * add_page;
	points += po;
}

int Vip::exchange(int p)
{
	int amount;
	if (p % exchange_page != 0)
	{
		p -= p % exchange_page;
		points -= p;
		amount = p / exchange_page;
	}
	else
	{
		points -= p;
		amount = p / exchange_page;
	}
	return amount;
}

void Vip::print()
{
	cout << "贵宾会员" << number << "--" << name << "--" << points << endl;
}

int main()
{
	Member* pm;
	int number, points, apage, epage;
	int amount, change_point;
	string name;

	cin >> number >> name >> points;
	Member mm(number, points, name);
	pm = &mm;
	cin >> amount >> change_point;
	pm->add(amount);
	pm->exchange(change_point);
	pm->print();

	cin >> number >> name >> points >> apage >> epage;
	Vip vv(number, points, name, apage, epage);
	pm = &vv;
	cin >> amount >> change_point;
	pm->add(amount);
	pm->exchange(change_point);
	pm->print();

	return 0;
}

B.二、金属加工（期末模拟）

题目描述

在金属加工中，金属具有硬度、重量、体积的属性（都是整数），包括四种操作：
1、合并，每两块金属可以合并成一块新的金属。新金属的重量等于原两块金属的重量之和，体积和硬度也类似计算。
2、巨化，金属通过熔炼风吹的方法会巨化，体积变大n倍，重量和硬度不变
3、硬化，在金属中加入高分子材料可以硬化金属，每提升硬度一级，重量和体积都增加10%。
4、软化，在金属中加入特殊化学溶液可以降低金属硬度，每降低硬度一级，重量和体积都减少10%

用类来描述金属，用运算符重载方式实现金属的四种操作，并定义打印函数，具体要求如下
1、用加法运算符、友元的方式实现合并
2、用乘法运算符、友元的方式实现巨化，含两个参数：金属对象、巨化倍数
3、用++运算符、成员函数、前增量的方式实现硬化
4、用–运算符、成员函数、后增量的方式实现软化
5、打印函数用来输出金属的信息，输出格式看参考样本

操作中所有属性的运算结果都只保留整数部分。

上述所有类属性都不是public，用面向对象思想和C++语言实现上述要求

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
#include<iostream>
using namespace std;

class Mental
{
protected:
	int hardness;
	int weight;
	int volume;
public:
	Mental(){}
	Mental(int h,int w,int v):hardness(h),weight(w),volume(v){}
	friend Mental operator+ (Mental m1,Mental m2);
	friend Mental operator*(Mental m, int n);
	Mental &operator++()
	{
		hardness++;
		volume *= 1.1;
		weight *= 1.1;
		return *this;
	}
	Mental& operator--(int)
	{
		hardness--;
		volume *= 0.9;
		weight *= 0.9;
		return *this;
	}
	void print();
};

Mental operator+(Mental m1, Mental m2)
{
	Mental m3;
	m3.hardness = m1.hardness + m2.hardness;
	m3.volume = m1.volume + m2.volume;
	m3.weight = m1.weight + m2.weight;
	return m3;
}

Mental operator*(Mental m, int n)
{
	m.volume *= n;
	return m;
}

void Mental::print()
{
	cout << "硬度" << hardness << "--重量" << weight << "--体积" << volume << endl;
}

int main()
{
	int h, w, v;
	int n;
	cin >> h >> w >> v;
	Mental m1(h, w, v);
	cin >> h >> w >> v;
	Mental m2(h, w, v);
	Mental m3;
	m3 = m1 + m2;
	m3.print();
	cin >> n;
	m3 = m1 * n;
	m3.print();
	++m1;
	m1.print();
	m2--;
	m2.print();

	return 0;
}

C.三、加密模板（期末模拟）

题目描述

加密机制包括明文、密文、密钥。用密钥对明文进行加密后就得到密文。
在古典加密机制中，偏离值是一种常见的方法，加密过程为
1、在已知数据中找出最大值
2、用最大值减去各个数值，得到相应的偏离值
3、偏离值加上密钥就得到密文

例如明文为1 2 3 4 5，密钥是10，加密过程为：
1、找出明文的最大值是5
2、用5减去明文的各个数值，得到偏离值4 3 2 1 0
3、用偏离值加上密钥，得到密文14 13 12 11 10
定义一个函数模板，名为max，参数包括数组和数组长度，返回值是数组中的最大值，要求支持整数、浮点数和字符三种类型。

用类模板定义一个加密类，包含四个属性：明文、密文、密钥、长度，前三个属性都是同一种类型，长度是整数。长度是指明文的长度。
类模板包含操作构造、加密、打印，说明如下：
1、加密是调用函数模板max得到数组最大值，按照前面的方法使用最大值和密钥进行加密，得到密文
2、打印是输出密文

要求类模板支持整数、浮点数和字符三种类型。
参考代码给出了加密类界面（只支持整数类型）、主函数（支持三种数据类型），程序要求
1、根据要求编写函数模板max
2、使用类模板方法改造加密类界面，不能增加任何属性和操作，必须在类外实现构造函数和加密方法
3、主函数不能有任何修改
上述所有类属性都不是public，用面向对象思想和C++语言实现上述要求

----参考代码----

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
//只支持整数类型的加密类界面
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
#include<iostream>
using namespace std;

template<class Type>
Type max(Type *p,int n)
{
	Type max = p[0];
	for (int i = 0; i < n; i++)
	{
		if (max < p[i])
        {
			max = p[i];
        }
	}
	return max;
}

template<class Type>
class Cryption
{
private:
	Type ptxt[100]; //明文
	Type ctxt[100]; //密文
	Type key; //密钥
	int len; //长度
public:
	Cryption(Type tk, Type tt[], int n) :key(tk), len(n) //参数依次对应密钥、明文、长度
	{
		for (int i = 0; i < len; i++)
		{
			ptxt[i] = tt[i];
		}
	}
	void encrypt(); //加密
	void print(); //打印，无需改造
};

template<class Type>
void Cryption<Type>::encrypt()
{
	for (int i = 0; i < len; i++)
	{
		ctxt[i] = key + (max(ptxt, len) - ptxt[i]);
	}
}

template<class Type>
void Cryption<Type>::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;
}

D.四、加湿风扇（期末模拟）

题目描述

已知家电有编号、功率的属性，属性都是整数，操作包括构造和打印等

电风扇继承家电的特点，新增两个属性（整数）：风向和风力，其中风向为0表示定向吹风，状态为1表示旋转吹风。
风扇包含两个新操作：风向控制和风力控制
1、风向控制含一个整数参数，无返回，把风向设置为参数值，参数为0表示定向吹风，为1表示旋转吹风。
2、风力控制含一个整数参数，无返回，把风力设置为参数值，参数表示风力级别，例如1级、2级、3级等。
加湿器继承家电的特点，新增两个属性（浮点数）：实际水容量和最大水容量

新增操作是预警，无参数，返回值为整数，当实际水容量不小于最大水容量的50%，则返回1；小于50%且不小于10%则返回2，小于10%则返回3
加湿风扇继承了风扇和加湿器的特点，新增属性档位（整数）
新增操作调整档位，含一个参数，无返回值，先设置档位为参数值，再调用风向控制和风力控制来设置相关属性，包括：
1、参数为0，不做其他属性修改
2、参数为1，设置定向吹风且风力1级
3、参数为2，设置旋转吹风且风力2级
4、参数为3，设置旋转吹风且风力3级

档位只可能是0、1、2、3四个数值，其他数值忽略。
加湿风扇重载打印操作，输出格式参考样本。输出要求如下：
1、如果风向为0，则输出定向吹风，风向为1则输出旋转吹风。
2、调用预警操作，并根据返回结果1、2、3输出不同信息，分别是：水量正常、水量偏低、水量不足

程序要求
1、采用虚拟继承机制实现上述电器的关系，明确谁是虚基类、基类、派生类
2、基类和派生类的构造要考虑虚基类、基类的属性构造
上述所有类属性都不是public，用面向对象思想和C++语言实现上述要求

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
#include<iostream>
using namespace std;

class appliance
{
protected:
	int number;
	int power;
public:
	appliance(){}
	appliance(int n,int p):number(n),power(p){}
	void print();
};

class Fan:virtual public appliance
{
protected:
	int w_direction;
	int w_power;
public:
	Fan(){}
	Fan(int n,int p,int w_d,int w_p):appliance(n,p),w_direction(w_d),w_power(w_p){}
	void d_control(int d)
	{
		w_direction = d;
	}
	void p_control(int p)
	{
		w_power = p;
	}
};

class Hum:virtual public appliance
{
protected:
	double  volume;
	double max_volume;
public:
	Hum(){}
	Hum(int n,int p,int v,int max):appliance(n,p),volume(v),max_volume(max){}
	int  warning();
};

int Hum::warning()
{
	if (volume >= 0.5 * max_volume)
		return 1;
	else if (volume >= (0.1 * max_volume) && volume < (0.5 * max_volume))
		return 2;
	else if (volume < (0.1 * max_volume))
		return 3;
}

class Hum_Fan :public Fan, public Hum
{
protected:
	int state;
public:
	
	Hum_Fan(int n, int p, int w_d, int w_p, int v, int max, int s) 
	{
		number = n;
		power = p;
		w_direction = w_d;
		w_power = w_p;
		volume = v;
		max_volume = max;
		state = s;
	}
	void control(int x);
	void print();
};

void Hum_Fan::control(int x)
{
		state = x;
		if (state == 0)
		{

		}
		else if (state == 1)
		{
			d_control(0);
			p_control(1);
		}
		else if (state == 2)
		{
			d_control(1);
			p_control(2);
		}
		else if (state == 3)
		{
			d_control(1);
			p_control(3);
		}
}

void Hum_Fan::print()
{
	cout << "加湿风扇--档位" << state << endl;
	cout << "编号" << number << "--功率" << power << "W" << endl;
	if (w_direction == 0)
	{
		cout << "定向吹风--风力" << w_power << "级" << endl;
	}
	else if (w_direction == 1)
	{
		cout << "旋转吹风--风力" << w_power << "级" << endl;
	}
	if (warning() == 1)
	{
		cout << "实际水容量" << volume << "升--水量正常" << endl;
	}
	else if (warning() == 2)
	{
		cout << "实际水容量" << volume << "升--水量偏低" << endl;
	}
	else if (warning() == 3)
	{
		cout << "实际水容量" << volume << "升--水量不足" << endl;
	}
}

int main()
{
	int t;
	int number, power, w_direction, w_power, volume, max_volume, state;
	int n;
	cin >> t;
	while (t--)
	{
		cin >> number >> power >> w_direction >> w_power >> volume >> max_volume >> state;
		Hum_Fan app(number, power, w_direction, w_power, volume, max_volume, state);
		cin >> n;
		app.control(n);
		app.print();
	}
	return 0;
}

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克，并且把数值放入斤、两、钱、克四个属性中
英国计重类新增了磅、盎司、打兰三个属性，并新增了两个操作：
1、计重转换Convert，功能与上述类似，例如2345克转成4磅9盎司4打兰1克，并且把数值放入对应的四个属性中
2、计重等价，重载类型转换运算符，实现将英国计重类的对象转换成中国计重类的对象，例如英国计重类对象en（2磅2盎司11打兰1克）等价于（转换成）中国计重类对象cn（2斤2两2钱1克）。

程序要求如下
1、参考代码框架不能做任何修改，在要求的地方添加代码
2、主函数不能有任何修改
以上数据纯粹为题目设计，方便计算，实际换算数据是不同的。

上述所有类属性都不是public，用面向对象思想和C++语言实现上述要求

----参考代码----

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#define _CRT_SECURE_NO_WARNINGS
#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)
	{
		strcpy(kind, tk);
		gram = tg;
	}
	virtual void print(ostream& out) = 0; // 输出不同类型的计重信息
};

// 中国计重
class CN : public Weight
{
protected:
	int jin, liang, qian;
public:
	CN(int j,int l,int q,int g,const char *p):jin(j),liang(l),qian(q)
	{
		gram = g;
		strcpy(kind, p);
	}
	void Convert(int g);
	void print(ostream& out);
};

void CN :: Convert(int g)
{
	jin = g / 500;
	liang = g % 500 / 50;
	qian = g % 500 % 50 / 5;
	gram = g % 500 % 50 % 5;
}

void CN::print(ostream& out)
{
	out << "中国计重:" << jin << "斤" << liang << "两" << qian << "钱" << gram << "克" << endl;
}

// 英国计重
class EN : public Weight
{
protected:
	int pound, ounce, beaten;
public:
	EN(int p,int o,int b,int g,const char *q):pound(p),ounce(o),beaten(b)
	{
		gram = g;
		strcpy(kind, q);
	}
	void Convert(int g);
	void print(ostream& out);
	operator CN()
	{
		int g;
		g = pound * 512 + ounce * 32 + beaten * 2 + gram;
		CN cn(g / 500, g % 500 / 50, g % 500 % 50 / 5, g % 500 % 50 % 5, "中国计重");
		return cn;
	}
};

void EN::Convert(int g)
{
	pound = g / 512;
	ounce = g % 512 / 32;
	beaten = g % 512 % 32 / 2;
	gram = g % 512 % 32 % 2;
}

void EN::print(ostream&out)
{
	out << "英国计重:" << pound << "磅" << ounce << "盎司" << beaten << "打兰" << gram << "克" << endl;
}


// 以全局函数方式重载输出运算符，代码3-5行....自行编写
// 重载函数包含两个参数：ostream流对象、Weight类对象，参数可以是对象或对象引用
// 重载函数必须调用参数Weight对象的print方法
ostream& operator<<(ostream& out, Weight& w)
{
	w.print(out);
	return out;
}

// 主函数
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;
}