大一C++考试题Word格式.docx
《大一C++考试题Word格式.docx》由会员分享，可在线阅读，更多相关《大一C++考试题Word格式.docx（20页珍藏版）》请在冰豆网上搜索。
for语句能够被改写成（）语句。
（A）
while
（B）
if
（C）
try
（D）
switch
[2]
语句：
for（intx=0,y=0;
!
x&
&
y<
=5;
y++,x=1-x）;
执行循环的次数是（）。
无数
[3]
下面数组定义合法的是（）。
ints[]="
string"
;
ints[5]={0,1,2,3,4,5};
chars="
chars[]={0,1,2,3,4,5};
[4]
执行下面语句：
inta[10]={1,2,3,4,5,6,7,8,9,10},*p=a;
则数值为8的表达式是（）。
*p+=7
*（p+8）
*p+8
p+7
[5]
假定E为一个类，则执行“Ee1（3）,e2[6],*pe[8];
”语句时，自动调用该类构造函数的次数为（）。
17
[6]
typedefstruct
{
intscore;
intyear;
}data;
datad,*p=&
d;
上面语句执行后，与d.score值相等为（）。
p->
d.score
（*p）.score
（*p）.d
data
[7]
假定有以下变量定义：
intk=8,x=21;
则能使x的值为5的表达式是（）。
x%=（k%=5）
x%=（k-k%5）
（x%=k）-（k%=5）
x%=k-k%5
[8]
结构体：
structstudent
{charname[10];
intage;
boolsex;
};
占内存字节数为（）。
20
18
sizeof（student）
[9]
已知：
inta,*pa=&
a;
输出指针pa值的十进制表示的方法是（）。
cout<
<
pa
*pa;
（longint）pa;
[10]
类的析构函数是在什么时间被自动调用的？
（）。
类创建时
创建对象时
销毁对象时
不自动调用
[11]
下面描述中，表达错误的是（）。
公有继承时基类中的public成员在派生类中仍是public的
公有继承是基类中的private成员在派生类中仍是private的
公有继承时基类中的protected成员在派生类中仍是protected的
私有继承时基类中的public成员在派生类中是private的
[12]
#include<
iostream>
usingnamespacestd;
classBase
{
charc;
public:
Base（charn）:
c（n）{}
~Base（）{cout<
c;
}
classDerived:
publicBase
Derived（charn）:
Base（n-1）,c（n）{}
~Derived（）{cout<
intmain（intargc,char*argv[]）
Derived（'
D'
）;
return0;
}
上面程序运行结果为（）。
CD
DC
D
C
[13]
任何类都至少拥有（）构造函数。
默认
拷贝
2个
赋值
[14]
关于多态，下面那些说法是正确的（）。
多态分静态的（运行时）和动态的（编译时）。
运行时的多态与类的层次结构无关。
在基类定义了虚函数后，在派生类中重新定义时必须加关键字virtual。
仅使用虚函数并不能实现运行时的多态性，还必须采用指针或引用来调用才能真正实现运行时的多态性。
[15]
下列哪一个描述是关于引用调用的（）。
形参是指针，实参是地址值
形参是引用，实参是变量
形参和实参都是变量
形参和实参都是数组名
[16]
已知类Myst有一个只需要一个double型参数的构造函数，且将运算符“-”重载为友元函数。
要使语句序列：
Mystx（3.2）,y（5.5）,z（0.0）;
z=（x-6.3）-（8.9-y）;
能够正常运行，运算符函数operator-应该在类中声明为（）。
friendMystoperator-（Myst&
Myst&
friendMystoperator-（Myst,Myst）;
friendMystoperator-（Myst,Myst&
Myst）;
二.
判断题（每小题1分，共10分）
请判断下列语句是否正确，如果正确请在下列的表格题号对应的空白内用笔打上√；
如果错误请在下列的表格题号对应的空白内用笔打上×
。
错打或未打均无分。
（）
定义数组chars1[]="
abc"
和chars2[]={'
a'
'
b'
c'
}，s1的数组长度小于s2的数组长度。
C++语言的跳转语句中，continue只能够用在循环语句中，而break可以不用在循环语句中。
使用内联函数可节省函数调用与返回时的开销，因此能够提高程序的运行速度。
在传值调用中，要求实参和形参的类型完全一致并且个数相等。
语句inta（10）,&
b=a,*p=&
中，b的值和*p的值是相等的。
运算符重载只能够实现成友元函数。
任何函数都必须有返回值。
定义一个对象时，系统只为该对象的数据成员开辟内存空间，而成员函数是同类对象共享的。
类的对象可以是自身类的成员变量。
模板类的成员函数若在类外实现，则必须是模板函数。
三.
写出程序执行结果（每小题6分，共30分）
阅读以下程序，并写出程序运行结果。
程序输出结果
voidExchange2（chara,charb）
c=a;
a=b;
b=c;
voidexchange（char*a,charb）
c=*a;
*a=b;
voidexchange（char*a,char*b）
*a=*b;
*b=c;
voidexchange（char&
a,char&
b）
intmain（intargc,char*argv[]）
chara,b;
a='
A'
b='
B'
Exchange2（a,b）;
cout<
a<
b;
exchange（&
a,&
b）;
a,b）;
exchange（a,b）;
usingnamespacestd;
#defineN5
voidtransp（inta[][N],intn）
inti,j,k;
for（i=0;
i<
n;
i++）
for（j=0;
j<
i;
j++）
{
k=a[i][j];
a[i][j]=a[j][i];
a[j][i]=k;
}
intn,i,j,x[N][N],k=0;
n=3;
x[i][j]=k++;
transp（x,n）;
{
cout<
x[i][j];
cout<
"
\n"
}
return0;
classB
protected:
inta;
virtualvoidCal（）
{
a+=a;
};
virtualintGetA（）
returna;
}
classD1:
publicB
intw;
inth;
D1（inttw,intth）:
w（tw）,h（th）{}
voidCal（）
a=w+h;
classD2:
D2（inttw,intth）:
a=w-h;
classD3:
D3（inttw,intth）:
a=w*h;
intmain（intargc,char*argv[]）
B*b[]={newD1（3,2）,newD2（3,2）,newD3（3,2）};
intsum=0;
for（inti=0;
i<
3;
i++）
b[i]->
Cal（）;
sum+=b[i]->
GetA（）;
计算结果为：
sum<
endl;
iostream.h>
classcomplex
complex（double,double）;
complex（complex&
complex（）;
complexoperator*（complex&
complex&
operator=（complex&
voiddisplay（）;
doublereal;
doubleimage;
complex:
:
complex（doublex,doubley）
{real=x,image=y;
complex（complex&
x）
Runingcopyconstructor\n"
real=x.real;
image=x.image;
complex（）
{real=image=0.0;
complexcomplex:
operator*（complex&
returncomplex（real*x.real,image*x.image）;
complex&
complex:
x）
Runingassignoperator\n"
real+=x.real;
image+=x.image;
return*this;
voidcomplex:
display（）
real<
+"
image<
i"
complexc1（3,9）;
complexc2（c1）;
complexc3;
c3=c1*c2;
c3.display（）;
template<
classT>
classStack
inttop;
T*elements;
intmaxSize;
Stack（int=30）;
~Stack（）{delete[]elements;
voidPush（constT&
data）;
TPop（）;
Stack<
T>
Stack（intmaxs）
maxSize=maxs;
top=-1;
elements=newT[maxSize];
voidStack<
Push（constT&
data）
elements[++top]=data;
TStack<
Pop（）
returnelements[top--];
inti;
chara[5]={'
k'
'
t'
s'
Stack<
char>
cstack;
5;
i++）cstack.Push（a[i]）;
i++）
cstack.Pop（）;
四.
综合题（每小题14分，共28分）
1、编写程序求这样四个整数
（
），使得以下等式成立：
程序输出结果如下。
//start：
程序开始
//end：
程序结束
2、已知函数
定积分公式：
（条件：
区间必须为偶数n个相等区间，
）
，
用虚函数来实现函数
和
的定积分，即：
将下面程序填写完整以完成题目要求。
string.h>
math.h>
#defineN2000
//----------------------------------
classSimpson{
doubleIntevalue,a,b;
//Intevalue积分值，a积分下限，b积分上限
virtualdoublefun（doublex）=0;
//被积函数声明为纯虚函数
Simpson（doublera=0,doublerb=0）:
a（ra）,b（rb）,Intevalue（0）
{}
voidIntegrate（）
doubledx;
inti;
dx=（b-a）/N;
Intevalue=;
//-----
（1）
for（i=1;
N;
i+=2）Intevalue+=4*fun（）;
//---
（2）
for（i=2;
i+=2）Intevalue+=2*fun（）;
//---（3）
Intevalue*=dx/3;
voidPrint（）{cout<
积分值="
Intevalue<
classA:
publicSimpson{
A（doublera,doublerb）:
Simpson（ra,rb）{};
doublefun（doublex）{;
}//以
作为被积函数--（4）
classB:
B（doublera,doublerb）:
}//以
作为被积函数--（5）
intmain（intargc,char*argv[]）
Aa（）;
//-----（6）
Simpson*s=&
s->
Integrate（）;
//动态计算函数
的定积分
Print（）;
Bb（）;
//-----（7）
s=&
升级会员 