C++考题.docx

C++考题.docx

《C++考题.docx》由会员分享，可在线阅读，更多相关《C++考题.docx（39页珍藏版）》请在冰豆网上搜索。

C++考题

《C++语言考题》（A卷）

一、选择题（每小题2分，共30分）

1、下列对函数的缺省参数的定义和描述及对函数的调用中正确的为。

A.voidshowmessage（char*text=”hello”,intlength,intcolor=0）;

B.intpalette=1;

intgetcolor（intpal）;

voidshowmessage（char*text,intlength=-1,intcolor=getcolor（palette））;

C.在设置了函数的缺省参数后，调用函数的对应实参就必须省略。

D.showmessage（“howareyou!

”,,8）;

2、下面对引用的定义及使用中正确的是。

A.int&Z;

B.intm=10;

float&t=&m;

C.voidf（int&a）

{a++;

cout<

}

voidmain（）

{f（3）;}

D.intd=2;

int&f（）

{d++;

returnd;

}

voidmain（）

{f（）;}

3、已知

constinta=1;

intb=2;

int*constcpint=&b;

constint*pcint=&a;

constintc=1;

intd=2;

constint&rcintc=c;

constint&rcintd=d;

下列赋值中正确的为。

A.*cpint=5;B.*pcint=5;C.rcintc=5;D.rcintd=5;

4、下列函数中，不能重载。

A.成员函数B.非成员函数C.析构函数D.构造函数

5、有以下类的说明，请指出错误的地方。

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）

{

a=c;b=d;

}

voidmain（）

{

An;

n.f（）;

cout<

f（）;

cout<

n.f（7,8）;

cout<

}

A.23B.23C.23D.23

34342323

34783478

7、关于缺省构造函数的下述描述中，是错误的。

A．如果没有定义构造函数或缺省构造函数，编译器会自动生成缺省构造函数。

B．如果类有缺省构造函数，则可以不传递参数而定义类对象。

C．缺省构造函数不对类对象数据成员赋初值。

D．如果定义了类的构造函数，则编译器不再生成缺省构造函数。

8、下面程序输出结果为。

#include"iostream.h"

classA

{

public:

virtualvoidf（）

{cout<<"A:

:

f（）"<

voidg（）

{f（）;}

};

classB:

publicA

{

public:

virtualvoidf（）

{cout<<"B:

:

f（）"<

};

voidmain（）

{Aa2;

a2.g（）;

A*pa=newB（）;

pa->f（）;

Bb;

b.f（）;

a2=b;

a2.g（）;

a2.f（）;

A&a=b;

a.f（）;

deletepa;

}

A.A:

:

f（）B.A:

:

f（）C.A:

:

f（）D.A:

:

f（）

B:

:

f（）B:

:

f（）A:

:

f（）B:

:

f（）

B:

:

f（）B:

:

f（）B:

:

f（）B:

:

f（）

B:

:

f（）A:

:

f（）A:

:

f（）B:

:

f（）

A:

:

f（）A:

:

f（）A:

:

f（）B:

:

f（）

B:

:

f（）B:

:

f（）A:

:

f（）B:

:

f（）

9、以下哪种构造函数不是单参数构造函数？

A．复制构造函数

B．只有第一个参数，其它参数为缺省的构造函数。

C．缺省构造函数。

D．转换构造函数。

10、下面的函数f1（）、f2（）、f3（）及对f3（）的调用（D）中，正确的为。

#include”iostream.h”

classA

{private:

inta;

public:

voidf1（）const--------------------------------（A）

{

a=2;

cout<

}

intf2（constintc）--------------------------（B）

{

a=3;

c=a;

returnc;

}

};

constint*f3（）-----------------------------（C）

{

staticintz=0;

z++;

return&z;

}

voidmain（）

{

Aa;

cout<

*f3（）=5;--------------------------------（D）

cout<<*f3（）;

}

11、下面程序中对成员函数的访问中，错误的是。

#include"iostream.h"

classA

{

public:

voidf1（）

{

cout<<"f1（）called"<

}

};

classB:

protectedA

{

public:

voidf2（）

{

cout<<"f2（）called"<

}

};

classC:

privateB

{

public:

voidf3（）

{

f1（）;---------------------------------------------（A）

cout<<"f3called"<

}

};

voidmain（）

{

Cc;

c.f2（）;-----------------------------------------------（B）

c.f3（）;------------------------------------------------（C）

Bb;

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"iostream.h"

#include"string.h"

classA

{

public:

A（char*st）;

~A（）;

private:

charstring[50];

staticinta;

};

A:

:

A（char*st）

{

strcpy（string,st）;

cout<

}

A:

:

~A（）

{

cout<

}

A:

:

a=2;

voidfun（）

{

AFunobj（"fun"）;

staticAStaobj（"sta"）;

cout<

}

AGlobobj（"Glob"）;

voidmain（）

{

intb=A:

:

a;

AMainobj（"Main"）;

cout<

for（inti=0;i

fun（）;

cout<

}

A.MainB.GlobC.GlobD.Glob

funMainMainMain

stafunfunfun

Globstastasta

stafunfunfun

funstafunfun

funfunstafun

stastafunMain

funfunMainsta

funstastaGlob

staMainGlob

GlobGlob

Main

17、下面标出的语句中使用正确的为。

#include

classctest

{

private:

staticintcount;

inttest;

public:

staticintgetcount（）

{

count=test;---------（A）

returncount;

}

intsettest（constint&a）

{

test=a;----------------（B）

returntest;

}

};

intctest:

:

count=5;

voidmain（）

{

constctestt1;

t1.settest（5）;------（C）

t1.getcount（）;-------（D）

}

18、下面程序输出结果。

#include"iostream.h"

classA

{

public:

A（intj）{b=j;}

intfun（intc）

{return（a+b*c）;}

inta;

private:

intb;

};

voidmain（）

{

Ax（8）;

intA:

:

*pa;

pa=&A:

:

a;

x.*pa=6;

int（A:

:

*pf）（int）;

pf=A:

:

fun;

A*p=&x;

cout<<（p->*pf）

（2）;

}

A．20B.22C.50D.66

19、下面程序的输出结果为。

#include"iostream.h"

classA

{

public:

A（）

{a=0;cout<<"A'sD.C.\n";}

A（inti）

{a=i;cout<<"A'sC.\n";}

~A（）

{cout<<"A'sD.\n";}

private:

inta;

};

voidmain（）

{

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’SC.A’SC.

A’SD.A’SD.

A’SD.A’SD.

A’SDA’SD.

A’SD.A’SD.

A’SD.A’SD

C.A’SD.C.D.程序有错误

A’SD.C无法运行

A’SC.

A’SC.

A’SD.

A’SD.

A’SD.

A’SD.

A’SD.

20、下面程序输出结果。

#include"iostream.h"

classA

{

public:

A（constchar*s）

{cout<

~A（）{}

};

classB:

virtualpublicA

{

public:

B（constchar*s1,constchar*s2）

:

A（s1）

{

cout<

}

};

classC:

virtualpublicA

{

public:

C（constchar*s1,constchar*s2）

:

A（s1）

{cout<

};

classD:

publicC,publicB

{

public:

D（constchar*s1,constchar*s2,

constchar*s3,constchar*s4）

:

B（s1,s3）,C（s1,s2）,b（s3,s4）,a（s1）,A（s4）

{cout<

Aa;

Bb;

};

voidmain（）

{

D*ptr=newD（"A","B","C","D"）;

deleteptr;

}

A.DB.DC.DD.D

BBBC

CCCB

AADD

CDAA

DAAA

A

21、下面程序输出结果。

#include"iostream.h"

classA

{

public:

virtualvoidact1（）;

voidact2（）;

voidact3（）{act1（）;act2（）;}

};

voidA:

:

act1（）

{

cout<<"A1"<

}

voidA:

:

act2（）

{

cout<<"A2"<

}

classB:

publicA

{public:

voidact1（）;

voidact2（）;

};

voidB:

:

act1（）

{

cout<<"B1"<

}

voidB:

:

act2（）

{

cout<<"B2"<

}

voidmain（）

{

Bb;

A&a1=b;

A*a2=newA（）;

b.act3（）;

b.act1（）;

a1.act3（）;

a1.act1（）;

a2->act3（）;

}

A.B1B.B1C.A1D.B1

A2A2A2A2

B1B1B1A1

A1B1A1B1

A2A2A2A2

B1B1B1A1

A1A1A1B1

A2A2A2A2

22、下面程序输出结果。

#include"iostream.h"

classA

{

public:

A（）{}

virtualvoidf（）

{

cout<<"A:

:

f\n";

}

voidh（）

{

cout<<"A:

:

h"<

}

};

classB:

publicA

{

public:

B（）{f（）;}

virtualvoidf（）

{

cout<<"B:

:

f\n";

}

voidh（）

{

cout<<"B:

:

h"<

}

};

classC:

publicB

{

public:

C（）{}

virtualvoidf（）

{

cout<<"C:

:

f\n";

}

voidh（）

{

cout<<"C:

:

h"<

}

};

voidg（A*aa）

{

aa->f（）;

aa->h（）;

}

voidmain（）

{

B*bp=newC;

g（bp）;

bp->h（）

deletebp;

}

A.C:

:

fB.C:

:

fC.B:

:

fD.B:

:

f

B:

:

fC:

:

fB:

:

fC:

:

f

A:

:

hA:

:

hA:

:

hA:

:

h

B:

:

hA:

:

hB:

:

hB:

:

h

23、下面程序输出结果。

#include"iostream.h"

classA

{

public:

A（inti,intj）{a=i,b=j;}

voidmove（intx,inty）

{a+=x;b+=y;}

voidshow（）

{cout<

protected:

inta,b;

};

classB:

publicA

{

public:

B（inti,intj,intk,intl）

:

A（i,j）,x（k）,y（l）

{}

voidshow（）

{cout<

cout<

voidfun（）{move（7,8）;}

voidf1（）{A:

:

show（）;}

private:

intx,y;

};

voidmain（）

{

Ae（5,6）;

Bd（1,2,3,4）;

d.fun（）;

d.show（）;

e.show（）;

d.fun（）;

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、下面程序输出结果。

#include"iostream.h"

classA

{

public:

virtual~A（）

{cout<<"A:

:

~A\n";}

};

classB:

publicA

{

public:

~B（）

{

cout<<"B:

:

~B\n";

}

};

voidmain（）

{

A*a1;

A*a2=newB（）;

Bb;

a1=&b;

}

A.B:

:

~BB.B:

:

~BC.B:

:

~BD.B:

:

~B

A:

:

~AA:

:

~AA:

:

~AA:

:

~A

A:

:

~AB:

:

~BB:

:

~B

A:

:

~A

25、下面程序输出结果。

#include"iostream.h"

classA

{

public:

A（inti）

{m=i;

cout<<"CON."<

}

A（inti,intj）

{m=i;j=8;

cout<<"CON."<

}

voidprint（）

{cout<

~A（）

{cout<<"DES."<

}

private:

intm;

};

voidmain（）

{

Amy=5;

my.print（）;

my=6;

my.print（）;

}

A.CON.5,8B.CON.5

DES.5DES.5

55

CON.6.8CON.6

DES.6DES.6

66

DES.6DES.6

C.CON.5D.CON.5

55

CON.6CON.6

6DES.6

DES.66

DES.6

26~27阅读下面程序并选择：

#include"iostream.h"

#include"string.h"

classcmessage

{

private:

char*buffer;

public:

cmessage（）

{buffer=newchar（'\0'）;}

cmessage（

（1））

{

（2）

}

~cmessage（）

{deletebuffer;

}

voiddisplay（）

{cout<

}

voidset（char*string）

{delete[]buffer;

buffer=newchar[strlen（string）+1];

strcpy（buffer,string）;

}

（3）operator=（（4））

{

（5）

};

voidmain（）

{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

（2）deletebuffer;

m.buffer=new（strlen（buffer）+1）;

strcpy（buffer,m.buffer）;

C.

（1）char*string

（2）buffer=new（strlen（string）+1）;

strcpy（buffer,string）;

D.

（1）cmessage&m

（2）buffer=new（strlen（m.buffer）+1）;

strcpy（buffer,m.buffer）

27、程序段（3）、（4）、（5）为。

A.（3）void

（4）cmessage&m

（5）deletebuffer;

buffer=new（strlen（m.buffer）+1）;

strcpy（buffer.m.buffer）;

B.（3）cmessage&

（4）cmessage&m

（5）buffer=new（strlen（m.buffer）+1）;

strcpy（buffer.m.buffer）;

return*this;

C.（3）cmessage

（4）cmessagem

（5）deletebuffer;

buffer=new（strlen（m.buffer）+1）;

strcpy（buffer.m.buffer）;

return*this;

D