上海大学1516级C++试题.docx
《上海大学1516级C++试题.docx》由会员分享，可在线阅读，更多相关《上海大学1516级C++试题.docx（18页珍藏版）》请在冰点文库上搜索。
上海大学1516级C++试题
上海大学2015～2016学年度秋季学期试卷（A卷）
课程名:
面向对象程序设计课程号:
08305121学分:
5
应试人声明：
我保证遵守《上海大学学生手册》中的《上海大学考场规则》，如有考试违纪、作弊行为，愿意接受《上海大学学生考试违纪、作弊行为界定及处分规定》的纪律处分。
应试人应试人学号应试人所在院系
题号
一（20）
二（20）
三（20）
四（40）
得分
——————————————————————————————————————
一、判断题（每小题2分，共20分）
1.类的构造函数的函数名与类名相同，可以重载构造函数。
（√）
2.类的析构函数可以被重载。
（×）
3.重载运算符函数不能改变运算符的操作数个数、优先级和结合方向。
（√）
4.引用在声明时必须对其初始化，以绑定某个已经存在的变量（或对象），
在该引用的生命期内，该绑定不能被更改。
（√）
5.指针变量在定义时必须对其初始化，以锁定某个已经存在的目标变量（或
对象），在该指针变量的生命期内，该指向不能被更改。
（×）
6.类的非静态成员函数均有一个隐含的形式参数this指针常量，用于指向
调用该函数的对象。
函数体中不能改变该指针常量的指向（即锁定调用该
函数的对象）。
（√）
7.派生类继承了基类的所有数据成员，并且在派生类的成员函数中都能直接
访问基类的访问属性为private的成员。
（×）
8.构造派生类对象时，先调用基类的构造函数，后执行派生类的构造函数。
析构派生类对象时，先调用基类的析构函数，后执行派生类的析构函数。
（×）
9.含纯虚函数的类称为抽象类，不能创建抽象类的对象，不能定义抽象类的
指针变量，不能声明抽象类的引用。
（×）
10.引用返回的函数可以作左值，也避免了函数值返回时创建与返回类型相同
的临时无名对象。
（√）
二、填空题（每空2分，共20分）如下设计了一个字符串类String，请根据运行结果，完成程序。
#include
#include
#include
usingnamespace①std;
classString
{
public:
String（constchar*str=""）
{
size=strlen（②str）;
x=size>0?
newchar[size]:
NULL;
if（x==NULL）size=0;
for（inti=0;ix[i]=str[i];
}
String（constString&s）:
x（③NULL）
{
*this=s;//直接利用深赋值运算符函数
}
virtual~String（）
{
if（x!
=NULL）delete④[]x;
size=0;
}
String&operator=（constString&s）
{
if（this==⑤&s）return*this;
if（x!
=NULL）delete[]x;
size=;
x=newchar[size];
if（x==NULL）size=0;
for（inti=0;ix[i]=[i];
return⑥*this;
}
⑦char&operator[]（intindex）{returnx[index];}
friendostream&operator<<（ostream&out,constString&s）
{
for（inti=0;i<;i++）
out<<[i];
return⑧out;
}
⑨friendistream&operator>>（istream&in,String&s）
{
stringstr;
in>>str;//利用C++字符串
s=String（））;//利用深赋值运算符
returnin;
}
friend⑩intCompare（constString&s1,constString&s2）
{
inti;
for（i=0;i<&&i<&&[i]==[i];i++）
;
if（i<&&i<
return[i]>[i]?
1:
-1;
elseif（i<&&i==
return1;
elseif（i==&&i<
return-1;
else
return0;
}
friendbooloperator<（constString&s1,constString&s2）
{returnCompare（s1,s2）<0;}
friendbooloperator<=（constString&s1,constString&s2）
{returnCompare（s1,s2）<=0;}
friendbooloperator>（constString&s1,constString&s2）
{returnCompare（s1,s2）>0;}
friendbooloperator>=（constString&s1,constString&s2）
{returnCompare（s1,s2）>=0;}
friendbooloperator==（constString&s1,constString&s2）
{returnCompare（s1,s2）==0;}
friendbooloperator!
=（constString&s1,constString&s2）
{returnCompare（s1,s2）!
=0;}
protected:
char*x;
intsize;
};
voiddisplay（constString&s1,constString&s2）
{
char*str[]={"小于","等于","大于"};
cout<<"\""<<<"\""<}
intmain（）
{Strings1（"Helloworld!
"）,s2（s1）;
运行结果
"Helloworld!
"等于"Helloworld!
"
"Helloworld!
"小于"helloworld!
"
"Helloworld!
"大于"Helloworld"
"Helloworld!
"大于"Helloworld"
""等于""
display（s1,s2）;
s2[0]='h';
display（s1,s2）;
s2="Helloworld";
display（s1,s2）;
s2="Helloworld";
display（s1,s2）;
s1="";s2="";
display（s1,s2）;
return0;
}
三、阅读程序写出运行结果（每行1分，共20分）
（10分）本题所涉及的Time类，相关头文件和源程序文件如下。
//头文件
#ifndefMYTIME_H
#defineMYTIME_H
#include
#include
usingnamespacestd;
classTime
{
public:
Time（inthour=0,intminute=0,intsecond=0）;
Time&operator++（）;
Timeoperator++（int）;
friendTimeoperator+（constTime&t,intn）;
friendostream&operator<<（ostream&out,constTime&t）;
friendistream&operator>>（istream&in,Time&t）;
protected:
inth,m,s;
};
#endif
//源程序文件
#include""
Time:
:
Time（inthour,intminute,intsecond）
:
h（hour）,m（minute）,s（second）//构造函数
{
}
Time&Time:
:
operator++（）
{
s++;
if（s==60）{s=0;m++;}
if（m==60）{m=0;h++;}
if（h==24）h=0;
return*this;
}
TimeTime:
:
operator++（int）
{
Timetemp（*this）;
++（*this）;
returntemp;
}
Timeoperator+（constTime&t,intn）
{
Timeresult（t）;
intx=*60+*60++n;
while（x<0）
x+=24*60*60;
x%=24*60*60;
=x%60;
=x/60%60;
=x/3600;
returnresult;
}
ostream&operator<<（ostream&out,constTime&t）
{
out<（2）<<<<':
'
<（2）<<<<':
'<（2）<<<returnout;
}
istream&operator>>（istream&in,Time&t）
{
charstr[200];
（str,200,':
'）;
=atoi（str）;
（str,200,':
'）;
=atoi（str）;
（str,200）;
=atoi（str）;
returnin;
}
运行结果
23:
59:
51
23:
59:
51
23:
59:
52
23:
59:
50
23:
59:
51
23:
59:
51
22:
59:
50
请输入时间:
23:
59:
59
23:
59:
59
00:
00:
00
10:
20:
30
//源程序文件（测试程序）
intmain（）
{
Timet0（23,59,50）,t;
t=t0;cout<<++t<t=t0;++t;cout<t=t0;++++t;cout<t=t0;cout<t=t0;t++;cout<t=t0;t++++;cout<t=t0;t=t+（-3600）;cout<cout<<"请输入时间（hh:
mm:
ss）:
";
cin>>t;
cout<cout<<++t<cout<return0;
}
（10分）以下4小题所涉及的Test1类，相关头文件和源程序文件如下。
//头文件
#ifndefTEST03_H
#defineTEST03_H
#include
usingnamespacestd;
classTest1
{
public:
Test1（inta=0）;
Test1（constTest1&t）;
virtual~Test1（）;
Test1&operator=（constTest1&t）;
staticintNum（）;
staticintSum（）;
friendostream&operator<<（ostream&out,constTest1&t）;
friendistream&operator>>（istream&in,Test1&t）;
protected:
staticintnum,sum;
intx;
};
voidShow（）;//普通的C++函数声明
#endif
//源程序文件
#include""
intTest1:
:
num=0,Test1:
:
sum=0;//静态数据成员定义及初始化
Test1:
:
Test1（inta）:
x（a）//构造函数
{
num++;sum+=x;
}
Test1:
:
Test1（constTest1&t）:
x//拷贝构造函数
{
num++;sum+=x;
}
Test1:
:
~Test1（）
{
num--;sum-=x;
}
Test1&Test1:
:
operator=（constTest1&t）//赋值运算符函数
{
sum+=-x;
x=;
return*this;
}
intTest1:
:
Num（）{returnnum;}
intTest1:
:
Sum（）{returnsum;}
ostream&operator<<（ostream&out,constTest1&t）
{
out<<;
returnout;
}
istream&operator>>（istream&in,Test1&t）
{
inttemp;
in>>temp;
Test1:
:
sum+=temp-;
=temp;
returnin;
}
voidShow（）//普通的C++函数
{
cout<<"Num="<:
Num（）
<<",\tSum="<:
Sum（）<}
//测试程序之一
#include""
运行结果=0,Sum=0
intmain（）
{
Show（）;
return0;
}
//测试程序之二
#include""
Test1x（100）;//创建一个全局对象
voidf（Test1t）
{
Show（）;
}
运行结果=1,Sum=100
Num=2,Sum=200
Num=1,Sum=100
intmain（）
{
Show（）;
f（x）;
Show（）;
return0;
}
//测试程序之三
#include""
voidf（Test1&t）
{
Show（）;
}
intmain（）
运行结果=1,Sum=100
Num=1,Sum=100
Num=1,Sum=100
{
Test1x（100）;//创建一个自动对象
Show（）;
f（x）;
Show（）;
return0;
}
//测试程序之四
#include""
intmain（）
运行结果=4,Sum=60
Num=5,Sum=90
Num=4,Sum=60
{
Test1x（10）,y（20）,a[2]={x,y}
Show（）;
Test1*p=newTest1;
*p=30;
Show（）;
deletep;
Show（）;
return0;
}
四、（40分）设计复数类。
要求运行时得到指定的输出结果。
①实现如下测试程序中用到的9个函数（每个函数3分。
无须定义拷贝构造函数、析构函数及赋值运算符函数）；
②自选3个运算符，并实现运算符函数重载（每个函数3分。
注意复数不能比较大小）；
③数据成员、类设计的其他部分（4分）。
【注意：
数学函数doubleatan2（doubley,doublex）;当x≠0时返回y/x的反正切值，当x=0时返回π/2或-π/2（正负号与y同号）】。
#include""
intmain（）
{
Complexx（3,4）,y（x）,z;//创建对象
cout<cout<<（）<<'\t';//计算复数的模长
（）=（）=1;//设置复数的实部、虚部
cout<<（）*180/M_PI<cout<+、*，迭代赋值*=
运行结果
（3,4）,（3,4）,（0,0）
545
（4,5）（-1,7）（-7,24）
cout<cout<<（x*=x）<return0;
}
//
#include
#include
usingnamespacestd;
classComplex
{
public:
Complex（doublereal=0,doubleimag=0）:
re（real）,im（imag）{}
double&Real（）{returnre;}
double&Imag（）{returnim;}
doubleAngle（）const{returnatan2（im,re）;}
doubleAbs（）const{returnsqrt（re*re+im*im）;}
friendComplexoperator+（constComplex&c1,constComplex&c2）
{
Complexresult（c1）;
+=;
+=;
returnresult;
}
friendComplexoperator*（constComplex&c1,constComplex&c2）
{
Complexresult;
=*-*;
=*+*;
returnresult;
}
Complex&operator*=（constComplex&c）
{
doublex=re*-im*;
im=re*+im*;
re=x;
return*this;
}
friendostream&operator<<（ostream&out,constComplex&c）
{
out<<'（'<<<<","<<<<'）';
returnout;
}
protected:
doublere,im;
};
升级会员 