C++考题Word文档下载推荐.docx
《C++考题Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《C++考题Word文档下载推荐.docx（39页珍藏版）》请在冰点文库上搜索。
classCsample
{
inta;
（A）
Csample（Csampleample）;
---------（B）
Csample（intval）:
a（val）---------（C）
{}
～Csample（）;
--------------------------（D）
};
6、判断下面程序的输出：
#include"
iostream.h"
inta=0,b=0;
classA
public:
inta,b;
voidf（intc=2,intd=3）
{
a=c;
b=d;
}
voidf（intc=3,intd=4）
b=d;
An;
n.f（）;
n.a<
'
'
n.b<
endl;
f（）;
n.f（7,8）;
a<
b<
A.23B.23C.23D.23
34342323
34783478
7、关于缺省构造函数的下述描述中，是错误的。
A．如果没有定义构造函数或缺省构造函数，编译器会自动生成缺省构造函数。
B．如果类有缺省构造函数，则可以不传递参数而定义类对象。
C．缺省构造函数不对类对象数据成员赋初值。
D．如果定义了类的构造函数，则编译器不再生成缺省构造函数。
8、下面程序输出结果为。
#include"
public:
virtualvoidf（）
{cout<
"
A:
:
f（）"
voidg（）
{f（）;
}
classB:
publicA
virtualvoidf（）
B:
{Aa2;
a2.g（）;
A*pa=newB（）;
pa->
f（）;
Bb;
b.f（）;
a2=b;
a2.f（）;
A&
a=b;
a.f（）;
deletepa;
A.A:
f（）B.A:
f（）C.A:
f（）D.A:
f（）
f（）B:
f（）A:
9、以下哪种构造函数不是单参数构造函数？
A．复制构造函数
B．只有第一个参数，其它参数为缺省的构造函数。
C．缺省构造函数。
D．转换构造函数。
10、下面的函数f1（）、f2（）、f3（）及对f3（）的调用（D）中，正确的为。
#include”iostream.h”
{private:
inta;
voidf1（）const--------------------------------（A）
a=2;
’‘<
intf2（constintc）--------------------------（B）
a=3;
c=a;
returnc;
};
constint*f3（）-----------------------------（C）
staticintz=0;
z++;
return&
z;
voidmain（）
Aa;
a.f1（）<
a.f2（3）;
*f3（）=5;
--------------------------------（D）
*f3（）;
11、下面程序中对成员函数的访问中，错误的是。
voidf1（）
cout<
f1（）called"
protectedA
voidf2（）
f2（）called"
classC:
privateB
voidf3（）
f1（）;
---------------------------------------------（A）
f3called"
Cc;
c.f2（）;
-----------------------------------------------（B）
c.f3（）;
------------------------------------------------（C）
b.f2（）;
-------------------------------------------------（D）
12、派生类的构造函数的成员初始化列表中，不能包含。
A．基类的构造函数。
B．派生类中对象成员的初始化。
C．基类中对象成员的初始化。
D．派生类中一般数据成员的初始化。
13、有关虚基类的描述中错误的是。
A．最派生类构造函数中的虚基类构造函数会被调用。
B．虚基类可以消除二义性。
C．每个派生类构造函数成员初始化器表中都包含有对虚基类构造函数的调用，故虚基类构造函数会被调用多次。
D．虚基类只有一个。
14、关于虚析构函数的下述描述中，是错误的。
A．基类中析构函数为虚析构函数，则派生类中的析构函数也为虚析构函数。
B．虚析构函数能保证delete运算符有效的释放基类及派生类对象。
C．将析构函数定义为虚析构函数是因为类中有虚函数。
D．虚析构函数并不能实现动态联编。
15、关于纯虚函数和抽象类的描述中，是错误的。
A．纯虚函数没有函数体。
B．抽象类及其派生类都可以定义对象。
C．若某个成员函数为纯虚函数，则该类为抽象类。
D．抽象类通常在类结构的顶层。
16、判断下面程序的输出结果。
#include"
string.h"
A（char*st）;
~A（）;
private:
charstring[50];
staticinta;
A（char*st）
strcpy（string,st）;
string<
~A（）
a=2;
voidfun（）
AFunobj（"
fun"
）;
staticAStaobj（"
sta"
AGlobobj（"
Glob"
intb=A:
AMainobj（"
Main"
cout<
for（inti=0;
i<
i++）
fun（）;
A.MainB.GlobC.GlobD.Glob
funMainMainMain
stafunfunfun
Globstastasta
funstafunfun
funfunstafun
stastafunMain
funfunMainsta
funstastaGlob
staMainGlob
GlobGlob
Main
17、下面标出的语句中使用正确的为。
#include<
iostream.h>
classctest
staticintcount;
inttest;
staticintgetcount（）
count=test;
---------（A）
returncount;
intsettest（constint&
test=a;
----------------（B）
returntest;
intctest:
count=5;
constctestt1;
t1.settest（5）;
------（C）
t1.getcount（）;
-------（D）
18、下面程序输出结果。
A（intj）{b=j;
intfun（intc）
{return（a+b*c）;
intb;
Ax（8）;
intA:
*pa;
pa=&
x.*pa=6;
int（A:
*pf）（int）;
pf=A:
fun;
A*p=&
x;
（p->
*pf）
（2）;
A．20B.22C.50D.66
19、下面程序的输出结果为。
A（）
{a=0;
A'
sD.C.\n"
;
A（inti）
{a=i;
sC.\n"
~A（）
{cout<
sD.\n"
{
Aa1;
Aa2[4]={
A（）,
a1,
5,
2.3
A.A’SD.C.B.A’SD.C.
A’SD.C.A’SC.
A’SC.A’SC.
A’SC.A’SC.
A’SD.A’SD.
A’SDA’SD.
A’SD.A’SD
C.A’SD.C.D.程序有错误
A’SD.C无法运行
A’SC.
A’SD.
20、下面程序输出结果。
A（constchar*s）
s<
~A（）{}
virtualpublicA
B（constchar*s1,constchar*s2）
A（s1）
s2<
C（constchar*s1,constchar*s2）
classD:
publicC,publicB
D（constchar*s1,constchar*s2,
constchar*s3,constchar*s4）
B（s1,s3）,C（s1,s2）,b（s3,s4）,a（s1）,A（s4）
s1<
Aa;
Bb;
D*ptr=newD（"
A"
"
B"
C"
D"
deleteptr;
A.DB.DC.DD.D
BBBC
CCCB
AADD
CDAA
DAAA
A
21、下面程序输出结果。
virtualvoidact1（）;
voidact2（）;
voidact3（）{act1（）;
act2（）;
voidA:
act1（）
A1"
act2（）
A2"
{public:
voidact1（）;
voidB:
B1"
B2"
a1=b;
A*a2=newA（）;
b.act3（）;
b.act1（）;
a1.act3（）;
a1.act1（）;
a2->
act3（）;
A.B1B.B1C.A1D.B1
A2A2A2A2
B1B1B1A1
A1B1A1B1
A1A1A1B1
22、下面程序输出结果。
A（）{}
f\n"
voidh（）
h"
B（）{f（）;
publicB
C（）{}
C:
voidg（A*aa）
aa->
h（）;
B*bp=newC;
g（bp）;
bp->
h（）
deletebp;
A.C:
fB.C:
fC.B:
fD.B:
f
B:
fC:
fB:
A:
hA:
h
hB:
23、下面程序输出结果。
A（inti,intj）{a=i,b=j;
voidmove（intx,inty）
{a+=x;
b+=y;
voidshow（）
protected:
inta,b;
B（inti,intj,intk,intl）
A（i,j）,x（k）,y（l）
{}
x<
y<
voidfun（）{move（7,8）;
voidf1（）{A:
show（）;
intx,y;
Ae（5,6）;
Bd（1,2,3,4）;
d.fun（）;
d.show（）;
e.show（）;
d.f1（）;
A.3,4B.3,4C.3,4D.3,4
1,21,212,148,10
12,145,612,145,6
1,21,219,2215,18
24、下面程序输出结果。
virtual~A（）
~A\n"
~B（）
~B\n"
A*a1;
A*a2=newB（）;
a1=&
A.B:
~BB.B:
~BC.B:
~BD.B:
~B
~AA:
~A
~AB:
~BB:
25、下面程序输出结果。
A（inti）
{m=i;
CON."
m<
A（inti,intj）
j=8;
'
j<
voidprint（）
DES."
intm;
Amy=5;
my.print（）;
my=6;
A.CON.5,8B.CON.5
DES.5DES.5
55
CON.6.8CON.6
DES.6DES.6
66
C.CON.5D.CON.5
CON.6CON.6
6DES.6
DES.66
DES.6
26~27阅读下面程序并选择：
classcmessage
char*buffer;
cmessage（）
{buffer=newchar（'
\0'
cmessage（
（1））
（2）
~cmessage（）
{deletebuffer;
voiddisplay（）
buffer<
\n'
voidset（char*string）
{delete[]buffer;
buffer=newchar[strlen（string）+1];
strcpy（buffer,string）;
（3）operator=（（4））
（5）
{cmessagemessage1;
message1.set（"
hello"
cmessagemessage2（message1）;
cmessagemessage3;
cmessagemessage4;
message4=message3=message2;
26．程序段
（1）、
（2）应为。
A.
（1）cmessagem
（2）deletebuffer;
buffer=new（strlen（m.buffer）+1）;
strcpy（buffer,m.buffer）;
B.
（1）cmessage&
m
m.buffer=new（strlen（buffer）+1）;
C.
（1）char*string
（2）buffer=new（strlen（string）+1）;
strcpy（buffer,string）;
D.
（1）cmessage&
（2）buffer=new（strlen（m.buffer）+1）;
strcpy（buffer,m.buffer）
27、程序段（3）、（4）、（5）为。
A.（3）void
（4）cmessage&
（5）deletebuffer;
buffer=new（strlen（m.buffer）+1）;
strcpy（buffer.m.buffer）;
B.（3）cmessage&
（5）buffer=new（strlen（m.buffer）+1）;
return*this;
C.（3）cmessage
（4）cmessagem
buffer=new（strlen（m.buffer）+1）;
D
升级会员 