上海大学级C试题.docx
《上海大学级C试题.docx》由会员分享,可在线阅读,更多相关《上海大学级C试题.docx(15页珍藏版)》请在冰豆网上搜索。
上海大学级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=s.size;
x=newchar[size];
if(x==NULL)size=0;
for(inti=0;ix[i]=s.x[i];
return⑥*this;
}
⑦char&operator[](intindex){returnx[index];}
friendostream&operator<<(ostream&out,constString&s)
{
for(inti=0;iout<return⑧out;
}
⑨friendistream&operator>>(istream&in,String&s)
{
stringstr;
in>>str;//利用C++字符串
s=String(str.c_str());//利用深赋值运算符
returnin;
}
friend⑩intCompare(constString&s1,constString&s2)
{
inti;
for(i=0;i;
if(ireturns1.x[i]>s2.x[i]?
1:
-1;
elseif(ireturn1;
elseif(i==s1.size&&ireturn-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分)
3.1(10分)本题所涉及的Time类,相关头文件和源程序文件如下。
//MyTime.h头文件
#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
//MyTime.cpp源程序文件
#include"MyTime.h"
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=(t.h*60+t.m)*60+t.s+n;
while(x<0)
x+=24*60*60;
x%=24*60*60;
result.s=x%60;
result.m=x/60%60;
result.h=x/3600;
returnresult;
}
ostream&operator<<(ostream&out,constTime&t)
{
out<(2)<'
<(2)<'<(2)<returnout;
}
istream&operator>>(istream&in,Time&t)
{
charstr[200];
in.getline(str,200,':
');
t.h=atoi(str);
in.getline(str,200,':
');
t.m=atoi(str);
in.getline(str,200);
t.s=atoi(str);
returnin;
}
运行结果(3.1)
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
//main.cpp源程序文件(测试程序)
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;
}
3.2(10分)以下4小题所涉及的Test1类,相关头文件和源程序文件如下。
//test03.h头文件
#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
//Test03.cpp源程序文件
#include"Test03.h"
intTest1:
:
num=0,Test1:
:
sum=0;//静态数据成员定义及初始化
Test1:
:
Test1(inta):
x(a)//构造函数
{
num++;sum+=x;
}
Test1:
:
Test1(constTest1&t):
x(t.x)//拷贝构造函数
{
num++;sum+=x;
}
Test1:
:
~Test1()
{
num--;sum-=x;
}
Test1&Test1:
:
operator=(constTest1&t)//赋值运算符函数
{
sum+=t.x-x;
x=t.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-t.x;
t.x=temp;
returnin;
}
voidShow()//普通的C++函数
{
cout<<"Num="<:
Num()
<<",\tSum="<:
Sum()<}
//3.2.1测试程序之一
#include"Test03.h"
运行结果(3.2.1)
Num=0,Sum=0
intmain()
{
Show();
return0;
}
//3.2.2测试程序之二
#include"Test03.h"
Test1x(100);//创建一个全局对象
voidf(Test1t)
{
Show();
}
运行结果(3.2.2)
Num=1,Sum=100
Num=2,Sum=200
Num=1,Sum=100
intmain()
{
Show();
f(x);
Show();
return0;
}
//3.2.3测试程序之三
#include"Test03.h"
voidf(Test1&t)
{
Show();
}
intmain()
运行结果(3.2.3)
Num=1,Sum=100
Num=1,Sum=100
Num=1,Sum=100
{
Test1x(100);//创建一个自动对象
Show();
f(x);
Show();
return0;
}
//3.2.4测试程序之四
#include"Test03.h"
intmain()
运行结果(3.2.4)
Num=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"Complex.h"
intmain()
{
Complexx(3,4),y(x),z;//创建对象
cout<cout<z.Real()=z.Imag()=1;//设置复数的实部、虚部
cout<cout<+、*,迭代赋值*=
运行结果(4.1)
(3,4),(3,4),(0,0)
545
(4,5)(-1,7)(-7,24)
cout<cout<<(x*=x)<return0;
}
//Complex.h
#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);
result.re+=c2.re;
result.im+=c2.im;
returnresult;
}
friendComplexoperator*(constComplex&c1,constComplex&c2)
{
Complexresult;
result.re=c1.re*c2.re-c1.im*c2.im;
result.im=c1.re*c2.im+c1.im*c2.re;
returnresult;
}
Complex&operator*=(constComplex&c)
{
doublex=re*c.re-im*c.im;
im=re*c.im+im*c.re;
re=x;
return*this;
}
friendostream&operator<<(ostream&out,constComplex&c)
{
out<<'('<returnout;
}
protected:
doublere,im;
};