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;
else
cout << "旋转吹风--风力" << 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和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;
}
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());
else
Insert(*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;
}