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、必须采用以下代码框架，在提示的地方增加代码，其他地方不能修改。

上述所有类属性都不是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;

}

输入

第一行输入普通会员的三个信息：编号、姓名、积分

第二行输入两个操作信息：消费金额、积分兑换数量，表示普通会员执行一次积分累加，一次积分兑换

第三行输入贵宾会员的五个信息：编号、姓名、积分、累加比例、兑换比例

第四行输入两个操作信息：消费金额、积分兑换数量，表示贵宾会员执行一次积分累加，一次积分兑换

输出

第一行输出普通会员执行两个操作后的信息，要求调用打印方法

第二行输出贵宾会员执行两个操作后的信息，要求调用打印方法

输入样例1

1001 John 500
244 300
8001 Jane 300 2 90
100 420

输出样例1

普通会员1001–John–444
贵宾会员8001–Jane–140

AC代码

#include<bits/stdc++.h>
using namespace std;class Member {
protected:int id, score;string name;
public:Member() {cin >> id >> name >> score;}virtual void print() {cout << "普通会员" << id << "--" << name << "--" << score << endl;}virtual  void Add(int v) {score += v;}virtual int Exchange(int v) {int ans = v / 100;score -= ans * 100;return ans;}};class VIP :public Member {  //贵宾会员类int addRate, exRate;
public:VIP() {cin  >> addRate >> exRate;}void print() {cout << "贵宾会员" << id << "--" << name << "--" << score << endl;}void Add(int v) {score += addRate * v;}int Exchange(int v) {int ans = v / exRate;score -= ans * exRate;return ans;}};int main() {Member* pm;pm = new Member;int t1, t2;cin >> t1 >> t2;pm->Add(t1);pm->Exchange(t2);pm->print();delete pm;pm = new VIP;cin >> t1 >> t2;pm->Add(t1);pm->Exchange(t2);pm->print();return 0;
}

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

题目描述

在金属加工中，金属具有硬度、重量、体积的属性（都是整数），包括四种操作：

1、合并，每两块金属可以合并成一块新的金属。新金属的重量等于原两块金属的重量之和，体积和硬度也类似计算。

2、巨化，金属通过熔炼风吹的方法会巨化，体积变大n倍，重量和硬度不变

3、硬化，在金属中加入高分子材料可以硬化金属，每提升硬度一级，重量和体积都增加10%。

4、软化，在金属中加入特殊化学溶液可以降低金属硬度，每降低硬度一级，重量和体积都减少10%

用类来描述金属，用运算符重载方式实现金属的四种操作，并定义打印函数，具体要求如下

1、用加法运算符、友元的方式实现合并

2、用乘法运算符、友元的方式实现巨化，含两个参数：金属对象、巨化倍数

3、用++运算符、成员函数、前增量的方式实现硬化

4、用–运算符、成员函数、后增量的方式实现软化

5、打印函数用来输出金属的信息，输出格式看参考样本

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

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

输入

第一行输入第一块金属的信息，包括硬度、重量、体积

第二行输入第二块金属的信息，包括硬度、重量、体积

第三行输入一个参数n，表示巨化n倍

输出

第一行输出两块金属合并后的信息

第二行输出第一块金属巨化n倍的信息

第三行输出第一块金属提升硬度一级后的信息

第四行输出第二块金属降低硬度一级后的信息

输入样例1

3 3000 300
5 5000 500
2

输出样例1

硬度8–重量8000–体积800
硬度3–重量3000–体积600
硬度4–重量3300–体积330
硬度4–重量4500–体积450

AC代码

#include<bits/stdc++.h>
using namespace std;class Jinshu {int yingdu, zhongliang, tiji;
public:Jinshu() {cin >> yingdu >> zhongliang >> tiji;}Jinshu(int y, int z, int t) {yingdu = y;zhongliang = z;tiji = t;}void print() {cout << "硬度" << yingdu << "--重量" << zhongliang << "--体积" << tiji << endl;}friend Jinshu operator + (const Jinshu& a, const Jinshu& b) {return Jinshu(a.yingdu + b.yingdu, a.zhongliang + b.zhongliang, a.tiji + b.tiji);}friend Jinshu operator *(const Jinshu& a, int n) {return Jinshu(a.yingdu , a.zhongliang , a.tiji * n);}Jinshu operator++() {yingdu++;zhongliang *= 1.1;tiji *= 1.1;return *this;}Jinshu operator--(int) {Jinshu Temp = *this;yingdu--;zhongliang *= 0.9;tiji *= 0.9;return Temp;}
};int main() {Jinshu j1, j2;int n;cin >> n;(j1 + j2).print();(j1 * n).print();(++j1).print();j2--;j2.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++语言实现上述要求

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

//只支持整数类型的加密类界面

class Cryption {

int ptxt[100];//明文

int ctxt[100];//密文

int key;//密钥

int len;//长度

public:

Cryption(int tk, int tt[], int tl); //参数依次对应密钥、明文、长度

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 ic(ik, itxt, length);

ic.Encrypt();

ic.Print();

//浮点数加密

cin>>dk>>length;

for (i=0; i<length; i++)

cin>>dtxt[i];

Cryption dc(dk, dtxt, length);

dc.Encrypt();

dc.Print();

//字符加密

cin>>ck>>length;

for (i=0; i<length; i++)

cin>>ctxt[i];

Cryption cc(ck, ctxt, length);

cc.Encrypt();

cc.Print();

return 0;

}

输入

第一行输入整数类型的信息，包括密钥、长度、明文

第二行输入浮点数类型的信息，包括密钥、长度、明文

第三行输入字符类型的信息，包括密钥、长度、明文

输出

三行分别输出三种类型的密文

输入样例1

10 5 1 2 3 4 5
11.11 4 1.1 2.2 3.3 4.4
O 3 a b c

输出样例1

14 13 12 11 10
14.41 13.31 12.21 11.11
Q P O

AC代码

#include<bits/stdc++.h>
using namespace std;template<class T>
T Max(vector<T>& v) {return *max_element(v.begin(), v.end());
}//只支持整数类型的加密类界面
template<class T>
class Cryption {vector<T>ptxt;//明文vector<T>ctxt;//密文T key;//密钥int len;//长度
public://参数依次对应密钥、明文、长度Cryption(T tk, vector<T>& ptxt, int tl) {this->ptxt = ptxt;len = tl;key = tk;ctxt.resize(tl);}Cryption(T tk, T* ptxt, int tl) :ptxt(ptxt, ptxt + tl) {len = tl;key = tk;ctxt.resize(tl);}void Encrypt() {T max_value = Max(ptxt);for (int i = 0; i < len; i++)ctxt[i] = (max_value - ptxt[i]) + key;}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;}

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++语言实现上述要求

输入

第一行输入t，表示有t个实例

第二行输入一个加湿风扇的信息，依次包括编号、功率、风向、风力、实际水容量、最大水容量 档位

第三行输入一个参数，表示调档操作的档位，然后执行调档操作。

以此类推，输入t个实例

输出

对于每个实例，调用打印操作输出加湿风扇的最终状态

输入样例1

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

加湿风扇–档位1
编号1001–功率1000W
定向吹风–风力1级
实际水容量3升–水量正常
加湿风扇–档位3
编号2002–功率2000W
旋转吹风–风力3级
实际水容量1升–水量不足
加湿风扇–档位0
编号3003–功率3000W
定向吹风–风力3级
实际水容量2升–水量偏低

AC代码

#include<bits/stdc++.h>
using namespace std;class Jiadian {
protected:int id, gonglv;int Fengxiang, Fengli;
public:Jiadian(){}virtual void print() = 0;
};class Shan :virtual public Jiadian{
protected:
public:void SetFengxiang(int v) {Fengxiang = v;}void SetFengli(int v) {Fengli = v;}
};class ShiQi :virtual public Jiadian {
protected:double shijishui, zuidashui;
public:int yujin() {if (shijishui >= zuidashui * 0.5)return 1;if (shijishui >= zuidashui * 0.1)return 2;return 3;}
};class JiaShiShan :public Shan, public ShiQi {int dangwei;
public:JiaShiShan() {cin >> id >> gonglv >> Fengxiang >> Fengli >> shijishui >> zuidashui >> dangwei;}void SetDangwei(int v) {if (v == 0)return;if (v == 1) {dangwei = v;SetFengxiang(0);SetFengli(1);}else if (v == 2) {dangwei = v;SetFengxiang(1);SetFengli(2);}else if (v == 3) {dangwei = v;SetFengxiang(1);SetFengli(3);}}void print() {cout << "加湿风扇--档位" << dangwei << endl;cout << "编号" << id << "--功率" << gonglv << "W" << endl;if (Fengxiang == 0)cout << "定向吹风--风力" << Fengli << "级" << endl;elsecout << "旋转吹风--风力" << Fengli << "级" << endl;string temp[] = { "", "水量正常","水量偏低","水量不足" };cout << "实际水容量" << shijishui << "升--" << temp[yujin()] << endl;}
};int main() {int t;cin >> t;while (t--){JiaShiShan j;int v;cin >> v;j.SetDangwei(v);j.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++语言实现上述要求

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

class CN; //提前声明

class EN; //提前声明

class Weight{ //抽象类

protected:

char kind[20]; //计重类型

int gram; //克

public:

Weight (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

1234
2345

输出样例1

中国计重:2斤4两6钱4克
英国计重:4磅9盎司4打兰1克
中国计重:4斤6两9钱0克

AC代码

#include<bits/stdc++.h>
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)const = 0; //输出不同类型的计重信息
};class CN : public Weight { //中国计重
//....类定义自行编写int jin, liang, qian;
public:CN(int j, int l, int q,int k,const char lei[]) {jin = j;liang = l;qian = q;gram = k;strcpy(kind, lei);}void Print(ostream& out)const {out << "中国计重:" << jin << "斤" << liang << "两" << qian << "钱" << gram << "克" << endl;}void Convert(int v) {jin = v / 500;v %= 500;liang = v / 50;v %= 50;qian = v / 5;v %= 5;gram = v;}};class EN : public Weight { //英国计重
//....类定义自行编写int jin, liang, qian;
public:EN(int j, int l, int q, int k, const char lei[]) {jin = j;liang = l;qian = q;gram = k;strcpy(kind, lei);}void Print(ostream& out)const {out << "英国计重:" << jin << "磅" << liang << "盎司" << qian << "打兰" << gram << "克" << endl;}void Convert(int v) {jin = v / 512;v %= 512;liang = v / 32;v %= 32;qian = v / 2;v %= 2;gram = v;}operator CN() {CN cn(0, 0, 0, 0, "中国计重");int v = 512 * jin + 32 * liang + 2 * qian + gram;cn.Convert(v);return cn;}};ostream& operator<<(ostream& o, const Weight& w) {w.Print(o);return o;
}//以全局函数方式重载输出运算符，代码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;
}

F. 附加题、组链表与通讯录（期末模拟）

题目描述

组链表是一种常用的数据结构，它由数组加链表组成，往往用于信息检索中。

每个链表由n个链表结点组成，每个链表都有头结点，头结点不存放实际数据，纯粹作为一个索引。

所有链表的头结点组成一个数组，即数组的每个元素都是一个链表头结点，它的后面延伸着一个链表。

例如一个通讯录包含五个联系人，每个联系人都有姓名和电话，每个联系人都对应一个链表结点。

Tom 8111

Any 1222

Ken 2333

Kim 2444

Tim 8222

我们先创建一个数组包含26个链表头结点，对应26个大写字母。因为有五个联系人，因此创建五个链表结点

因为上述联系人的姓名的首字母为A\K\T，因此把五个链表结点分别加入到三个头结点之后，形成三个链表。

其他字母的头结点因为无联系人，所以是空链表。构成组链表如下所示

A–Any.1222

K–Kim.2444–Ken.2333

T–Tim.8222–Tom.8444

现在使用组链表来实现通讯录，通讯录是多个联系人的信息集合，每个联系人都包含姓名和电话属性。

每个联系人对应一个链表结点，姓名首字母相同的联系人放在同一个链表中。联系人的类定义基本写好，如下参考代码

通讯录的类界面如下代码，操作包括：

1、该类没有构造函数，使用输入函数Input实现数据的输入和通讯录的初始化

2、打印函数Print，输出整个通讯录，输出格式参考样本

3、插入新的联系人，重载运算符+=来实现，如果联系人姓名已经存在，则用新的电话覆盖旧电话

注意：插入采用头插法，即新结点直接插入头结点之后

4、查找联系人姓名，重载运算符()来实现，查找成功返回链表结点指针，失败返回NULL

5、合并两个通讯录，重载运算符+来实现，合并结果放在第一个通讯录中，即左操作数。

通讯录的合并实际上是两个相同首字母的链表合并。对于相同首字母的两个链表i和j合并过程如下：

1）第二个链表j从头开始，取出联系人信息，在第一个链表i中查找。

2）如果联系人已存在，则用第二个通讯录的电话覆盖第一个通讯录的电话

3）如果联系人不存在，则把联系人插入到第一个链表i中

程序要求

1、联系人类定义和通讯录的类定义仅供参考，可自行定义

2、主函数代码不能修改

3、必须使用组链表来实现通讯录

4、通讯录类的插入、查找、合并操作都必须基于链表结点来操作。

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

const int hmax=26;

class Info { //联系人，用一个链表结点表示

string name; //姓名

int phoneNo; //电话

public:

Info* next; //指向下一个结点

Info(string tn= “no name”, int pno=0)

{name = tn;

phoneNo = pno;

next = NULL;

}

void Print()

{cout<<name<<“–”<<phoneNo<<endl;}

//属性的get和set方法…自行定义

};

class PhoneBook {//组链表方式实现通讯录

//…自行增加一些操作

//提示：把插入和查找先写成内部函数，再被运算符重载调用，会更方便

public:

Info Table[hmax];//链表头结点数组，对应26个大写字母

//以下定义五个操作：输入Input、打印Print、插入、合并、查找

//具体操作看前面说明

};

//…PhoneBook类成员函数，类外实现，自行编写

//----主函数----

int main()

{string tname;

int i, tno;

Info *p;

PhoneBook pb;

pb.Input(); //接收输入数据，初始化第一个通讯录

//两次姓名查找

for (i=0; i<2; i++)

{cin>>tname;

p = pb(tname); //调用()运算符，实现查找

if §p->Print(); //查找成功，输出联系人信息

else cout<<“查找失败”<<endl; //查找失败，输出提示信息

}

//一次插入

cin>>tname>>tno;

Info temp(tname, tno);

pb += temp; //调用+=运算符，实现插入新联系人

//通讯录合并

PhoneBook pc;

pc.Input(); //初始化第二个通讯录

pb = pb+pc; //调用+运算符，实现合并

pb.Print(); //输出所有操作后的通讯录

return 0;

}

输入

第一行输入n，表示第一个通讯录有n个联系人

接着n行，每行输入一个联系人的信息：姓名、电话

接着两行，每行输入一个联系人姓名，查找该联系人是否在通讯录中，并输出相应结果

接着一行，输入一个联系人的信息：姓名、电话，执行插入操作

接着一行，输入m，表示第二个通讯录有m个联系人

接着m行，每行输入一个联系人的信息：姓名、电话

输入完毕后，把第一个通讯录和第二个通讯录合并

假定联系人姓名都是英文字母，且首字母大写。

输出

按照主函数执行过程输出

输入样例1

4
Tom 8111
Any 1222
Ken 2333
Kim 2444
Any
Ben
Tim 8222
2
Tom 8444
Ann 1333

输出样例1

Any–1222
查找失败
A–Ann.1333–Any.1222–
K–Kim.2444–Ken.2333–
T–Tim.8222–Tom.8444–

AC代码

#include<bits/stdc++.h>
using namespace std;const int hmax = 26;class Info { //联系人，用一个链表结点表示string name; //姓名int phoneNo; //电话
public:Info* next;  //指向下一个结点Info(string tn = "no name", int pno = 0, Info* next = NULL){name = tn;phoneNo = pno;this->next = next;}void Print(){cout << name << "--" << phoneNo << endl;}string getName() { return name; }int getNo() { return phoneNo; }void setNo(int v) {phoneNo = v;}//属性的get和set方法....自行定义};class PhoneBook {//组链表方式实现通讯录//....自行增加一些操作//提示：把插入和查找先写成内部函数，再被运算符重载调用，会更方便public:int len[hmax] = { 0 };Info* Table[hmax];//链表头结点数组，对应26个大写字母//以下定义五个操作：输入Input、打印Print、插入、合并、查找void Input() {int t;cin >> t;for (int i = 0; i < 26; i++)Table[i] = new Info;while (t--) {string name;int no;cin >> name >> no;Insert(Info(name, no));}}void Insert(Info Node) {char ch = Node.getName()[0];len[ch - 'A']++;//cout << "insert:" << Node.getName() << endl;Info* p = Table[ch - 'A'];p->next = new Info(Node.getName(), Node.getNo(), p->next);}Info* operator ()(string name) {Info* p = Table[name[0] - 'A']->next;while (p) {if (p->getName() == name)return p;p = p->next;}return NULL;}void Print() {for (char ch = 'A'; ch <= 'Z'; ch++) {if (!len[ch - 'A'])continue;cout << ch << "--";for (Info* p = Table[ch - 'A']->next; p; p = p->next)cout << p->getName() << "." << p->getNo() << "--";cout << endl;}}PhoneBook& operator+=(Info Node) {Info* p = (*this)(Node.getName());if (!p)Insert(Node);else p->setNo(Node.getNo());return *this;}PhoneBook& operator+(PhoneBook& a) {for (int i = 0; i < 26; i++) {for (Info* p = a.Table[i]->next; p; p = p->next) {Info* s = (*this)(p->getName());if (s)s->setNo(p->getNo());elseInsert(*p);}}return *this;}//具体操作看前面说明};//...PhoneBook类成员函数，类外实现，自行编写//----主函数----int main(){string tname;int i, tno;Info* p;PhoneBook pb;pb.Input(); //接收输入数据，初始化第一个通讯录//两次姓名查找for (i = 0; i < 2; i++){cin >> tname;p = pb(tname); //调用()运算符，实现查找if (p)p->Print(); //查找成功，输出联系人信息else cout << "查找失败" << endl; //查找失败，输出提示信息}//一次插入cin >> tname >> tno;Info temp(tname, tno);pb += temp; //调用+=运算符，实现插入新联系人//通讯录合并PhoneBook pc;pc.Input(); //初始化第二个通讯录pb = pb + pc; //调用+运算符，实现合并pb.Print(); //输出所有操作后的通讯录return 0;}