上海大学修订级C++试题Word文档格式.docx
《上海大学修订级C++试题Word文档格式.docx》由会员分享，可在线阅读，更多相关《上海大学修订级C++试题Word文档格式.docx（17页珍藏版）》请在冰豆网上搜索。
usingnamespacestd;
class①LinkList;
//提前声明
classNode
{
public:
Node（intx=0）:
data（x）{}
②friendclassLinkList;
private:
intdata;
Node③*next;
};
classLinkList
Node*head;
LinkList（intn=0,int*array=NULL）
{
Node*p;
head=NULL;
for（inti=④n-1;
i>
=0;
i--）
{
p=newNode;
p->
data=（array!
=NULL）?
array[i]:
0;
next=head;
⑤head=p;
}
}
LinkList（constLinkList&
link）
head=⑥NULL;
*this=link;
virtual~LinkList（）
FreeList（）;
⑦LinkList&
operator=（constLinkList&
if（⑧&
link==this）
return*this;
Node*p,*q;
for（p=link.head;
⑨p!
=NULL;
p=p->
next）
if（head==NULL）
head=q=newNode（p->
data）;
else
{
q->
next=newNode（p->
q=q->
next;
}
⑩q->
next=NULL;
return*this;
voidFreeList（）
while（?
head!
=NULL）
p=head;
?
head=head->
next;
deletep;
voidShowList（ostream&
out）?
const
out<
"
head"
;
for（Node*p=head;
p!
=NULL;
out<
->
<
p->
data;
NULL"
ostream&
operator<
（ostream&
out,constLinkList&
运行结果
head->
3->
7->
2->
1->
NULL
link.ShowList（?
out）;
return?
out;
}
intmain（）
intn,a[]={3,7,2,1};
n=sizeof（a）/sizeof（*a）;
LinkListlinkA（n,a）,linkB（linkA）,linkC;
cout<
linkA<
'
\n'
linkB<
linkC<
endl;
linkC=linkA;
return0;
三、阅读程序写出运行结果（每行1分，共25分）
1.（7分）有关构造与析构的顺序
classTest
Test（inta=0,intb=0）:
x（a）,y（b）{}
~Test（）
if（x==y）
cout<
数据成员的值相同，都等于"
x<
else
数据成员的值不同，分别为"
"
y<
friendostream&
out,constTest&
t）
（"
t.x<
t.y<
）"
returnout;
运行结果
（1）
（10,0）
（0,0）
（2,3）
数据成员的值不同，分别为10,0
退出程序，返回操作系统
数据成员的值不同，分别为2,3
数据成员的值相同，都等于0
intx,y;
Test*p,t1;
p=newTest（10）;
Testt2（2,3）;
*p<
<
t1<
<
t2<
deletep;
退出程序，返回操作系统"
2.以下两小题所涉及的类设计，头文件如下。
//test.h
cmath>
classBASE
BASE（doublex=0,doubley=0）:
_x（x）,_y（y）{}
virtualvoidShow（ostream&
out）const=0;
protected:
double_x,_y;
out,constBASE&
x）
x.Show（out）;
returnout;
classComplex:
publicBASE
Complex（doublex=0,doubley=0）:
BASE（x,y）
voidShow（ostream&
out）const
if（_x!
=0）
_x;
if（_y>
0）out<
+'
_y<
i'
elseif（_y<
0）out<
-'
-_y<
if（_y!
cout<
friendComplexoperator+（constComplex&
a,constComplex&
b）
Complexc;
c._x=a._x+b._x;
c._y=a._y+b._y;
returnc;
friendComplexoperator*（constComplex&
c._x=a._x*b._x-a._y*b._y;
c._y=a._x*b._y+a._y*b._x;
doubleabs（）
returnsqrt（_x*_x+_y*_y）;
classPoint:
Point（doublex=0,doubley=0）:
（'
_x<
）'
friendPointoperator+（constPoint&
a,constPoint&
Pointc;
运行结果（2.1）
1+2i
3+4i
1i
10
y.abs（）:
5
4+6i
-5+10i
（1,2）
（3,4）
（4,6）
2.1（10分）测试程序
#include"
test.h"
Complexx（1,2）,y（3,4）,z1（0,1）,z2（10）;
<
z1<
z2<
y.abs（）<
z1=x+y;
z2=x*y;
Pointa（1,2）,b（3,4）;
a<
b<
a+b<
2.2（8分）测试程序
运行结果（2.2）
6+2i
5+10i
2+4i
（2,2）
（4,8）
Complexx（1,2）,y,z;
y=5+x;
z=5*x;
'
z<
x+x<
Pointa（1,2）,b,c;
b=a+1;
c=1+a;
c<
a=a+a;
a+a<
四、完成如下类的设计（25分）在GCC编译系统中，unsignedlonglong数据类型使整型数的取值范围得到扩展（
，即0~18446744073709551615）。
为了进一步扩展非负整数的取值范围设计了如下的类。
该类数据可精确计算至
，可处理36~37位非负十进制整数。
请在类的声明体外实现5个尚未定义的成员函数或友元函数。
最后写出程序的运行结果（每个函数定义4分，运行结果5分）。
//LLINT.h头文件
#ifndefLLINT_H
#defineLLINT_H
classLLINT
LLINT（unsignedlonglongx0=0,unsignedlonglongx1=0）;
//第一参数为低位
LLINT（constchar*str）;
LLINT&
operator++（）;
LLINToperator++（int）;
friendLLINToperator+（constLLINT&
x1,constLLINT&
x2）;
operator+=（constLLINT&
x）;
out,constLLINT&
friendLLINTatoLLINT（constchar*str）;
friendistream&
operator>
>
（istream&
in,LLINT&
friendbooloperator>
（constLLINT&
=（constLLINT&
friendbooloperator<
friendbooloperator==（constLLINT&
friendbooloperator!
staticconstunsignedlonglongBBILLION;
unsignedlonglonga1,a0;
//a1*1000000000000000000+a0可表示36~37位十进制非负整数
#endif
//LLINT.cpp源程序文件
LLINT.h"
iomanip>
constunsignedlonglongLLINT:
:
BBILLION=1000000000000000000ULL;
//静态常量数据成员的定义及初始化（10^18）
LLINT:
LLINT（unsignedlonglongx0,unsignedlonglongx1）
{//构造函数
unsignedlonglongx=x0/BBILLION;
a0=x0%BBILLION;
a1=x1+x;
LLINT（constchar*str）//转换构造函数（从C-字符串转换）
*this=atoLLINT（str）;
//直接利用成员函数实现转换构造
LLINTLLINT:
operator++（int）//后增量运算符函数
LLINTtemp（*this）;
++（*this）;
returntemp;
LLINToperator+（constLLINT&
x2）
LLINTs;
unsignedlonglongc=x1.a0+x2.a0;
s.a0=c%LLINT:
BBILLION;
s.a1=x1.a1+x2.a1+c/LLINT:
returns;
if（x.a1!
x.a1<
setfill（'
0'
）<
setw（18）<
x.a0<
）;
else
x.a0;
istream&
charstr[200];
in>
str;
x=atoLLINT（str）;
returnin;
booloperator>
（constLLINT&
if（x1.a1>
x2.a1）
returntrue;
elseif（x1.a1==x2.a1）
returnx1.a0>
x2.a0;
returnfalse;
booloperator<
if（x1.a1<
returnx1.a0<
=x2.a0;
LLINTatoLLINT（constchar*str）
LLINTx;
inti,j=0,n;
unsignedlonglongp0=1,p1=1;
for（n=0;
str[n];
n++）
;
if（n==0）returnx;
for（i=n-1;
if（'
=str[i]&
&
str[i]<
='
9'
if（j<
18）
x.a0+=p0*（str[i]-'
p0*=10;
elseif（j<
36）
x.a1+=p1*（str[i]-'
p1*=10;
j++;
returnx;
//LLINT_test.cpp测试程序
LLINTx（"
888777666555444333234567890987654321"
）,
y（100）,z;
z="
999999999999999999"
z++<
888777666555444333234567890987654321
100
0
999999999999999999
1000000000000000000
//请在类模板体外定义成员函数及友元函数。
【提示】可充分利用已有的函数。
//①（4分）前增量运算符函数重载
LLINT&
LLINT:
operator++（）
a0++;
if（a0==BBILLION）
a0=0;
a1++;
return*this;
//②（4分）加赋值运算符函数重载
operator+=（constLLINT&
*this=*this+x;
//③（4分）关系运算符（大于或等于）函数重载
//④（4分）关系运算符（等于）函数重载
booloperator==（constLLINT&
return（x1.a1==x2.a1）&
（x1.a0==x2.a0）;
//⑤（4分）关系运算符（不等于）函数重载
booloperator!
return（x1.a1!
=x2.a1）||（x1.a0!
=x2.a0）;
升级会员 