C++选择题2.docx

资源描述

C++选择题2.docx

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

C++选择题2.docx

C++选择题2

1.在语句cin>>data;中，cin是（类与对象3）

C++的关键字

类名

对象名

函数名

2.有如下程序：

3.#include

4.usingnamespacestd;

5.classComplex{

6.doublere,im;

7.public:

8.Complex（doubler,doublei）:

re（r）,im（i）{}

9.doublereal（）const{returnre;}

10.doubleimage（）const{returnim;}

11.Complex&operator+=（Complexa） {

12.re+=a.re;

13.im+=a.im;

14.return*this;

15.} };

16.ostream&operator<<（ostream&s,constComplex&z） {

17.returns<<’（’<

18.}

19.intmain（） {

20.Complexx（1,-2）,y（2,3）;

21.cout<<（x+=y）<

22.return0;

23.}

24.执行这个程序的输出结果是

（1,-2）

（2,3）

（3,5）

（3,1）

25.执行如下的程序段后，输出结果是（）。

26.cout.fill（’*’）;cout.width（6）;cout.fill（’#’）;

cout<<123<

###123

123###

***123

123***

27.在进行完任何C++流的操作后，都可以用C++流的有关成员函数检测流的状态；其中只能用于检测输入流状态的操作函数名称是（）

fail

eof

bad

good

28.在C++语言中，打开一个文件就是将这个文件与一个（）建立关联。

结构

流

类

对象

29.下面关于C++流的叙述中，正确的是（）。

cin是一个输入流对象

可以用ifstream定义一个输出流对象

执行语句序列char*y="PQMN";cout<

执行语句序列charx[80];cin.getline（x,80）;时，若键入Happynewyear则x中的字符串是"Happy"

30.在说明语句:

int*f（）;中,标识符f代表的是（）.

一个用于指向整型数据的指针变量

一个用于指向一维数组的行指针

一个用于指向函数的指针变量

一个返回值为指针型的函数名

31.有如下函数模板定义：

32.templateTfunc（Tx,Ty）{returnx*x+y*y;}

33.在下列对func的调用中，错误的是（）。

34.　func（3,5）;

35.func（3.0,5.5）;

36.　func（3,5.5）;

37.　func（3,5.5）;

38.在下列函数原型中，可以作为类AA构造函数的是（）。

voidAA（int）;

intAA（）;

AA（int）const;

AA（int）;

39.有如下函数模板定义：

40.template

41.Tfunc（Tx,Ty）{returnx*x+y*y;}

42.在下列对func的调用中，错误的是（）。

func（3,5）;

func（3.0,5.5）;

func（3,5.5）;

43.有如下函数模板templateTsquare（Tx）{returnx*x;}其中T是

函数形参

函数实参

模板形参

模板实参

44.在C++中，用于实现运行时多态性的是（）。

内联函数

重载函数

模板函数

虚函数

45.#include

46.usingnamespacestd;

47.classA{

48.public:

49.virtualvoidfunc1（）{cout<<"A1";}

50.voidfunc2（）{cout<<"A2";}

51.};

52.classB:

publicA{

53.public:

54.voidfunc1（）{cout<<"B1";}

55.voidfunc2（）{cout<<"B2";}

56.};

57.intmain（）{

58.A*p=newB;

59.p->func1（）;

60.p->func2（）;

61.return0;

62.}

63.运行此程序，屏幕上将显示输出

B1B2

A1A2

B1A2

A1B2

64.要实现运行时的多态性，必须通过（）调用虚函数

基类指针

派生类指针

对象名

派生类名

65.要实现动态联编，派生类中的虚函数（）

返回的类型可以与虚函数的原型不同

参数个数可以与虚函数的原型不同

参数类型可以与虚函数的原型不同

以上都不对

66.要实现动态联编，必须通过（）调用虚函数

对象指针

成员名限定

对象名

派生类名

67.虚函数支持多态调用，一个基类的指针可以指向派生类的对象，而且通过这样的指针调用虚函数时，被调用的是指针所指的实际对象的虚函数，而非虚函数不支持多态调用。

有如下程序：

68.#include

69.usingnamespacestd;

70.classBase

71.{

72.public:

73.virtualvoidf（）{cout<<"f0+";}

74.voidg（）{cout<<"g0+";}

75.

76.};

77.classDerived:

publicBase

78.{

79.public:

80.voidf（）{cout<<"f+";}

81.voidg（）{cout<<"g+";}

82.};

83.intmain（）

84.{

85.Derivedd;

86.Base*p=&d;

87.p->f（）;p->g（）;

88.return0;

89.}

90.运行时输出的结果是（）。

f+g+

f0+g+

f+g0+

f0+g0+

91.下面四个选项中，（）是用来声明虚函数的。

virtual

public

include

usingnamespace

92.下面描述中，正确的是（）。

virtual可以用来声明虚函数

含有纯虚函数的类是不可以用来创建对象的，因为它是虚基类

即使基类的构造函数没有参数，派生类也必须建立构造函数

静态数据成员可以通过成员初始化列表来初始化

93.下面关于C++语言的描述错误的是（）。

C++语言支持数据封装

C++语言中引入友元没有破坏封装性

C++语言允许函数名和运算符重载

C++语言支持动态联编

94.有如下程序

95.#include

96.usingnamespacestd;

97.classBase{

98.protected:

99.Base（）{cout<<’A’;}

100.Base（charc）{cout<

101.};

102.classDerived:

publicBase{

103.public:

104.Derived（charc）{cout<

105.};

106.intmain（）{

107.Derivedd1（’B’）;

108.return0;

109.}

110.执行这个程序屏幕上将显示输出______。

B BA AB BB

111.在公有派生情况下，有关派生类对象和基类对象的关系，下列叙述不正确的是（）。

派生类的对象可以赋给基类的对象

派生类的对象可以初始化基类的引用

派生类的对象可以直接访问基类中的成员

派生类的对象的地址可以赋给指向基类的指针

112.在公有继承的情况下，允许派生类直接访问的基类成员包括?

公有成员

公有成员和保护成员

公有成员保护成员和私有成员

保护成员

113.在公有继承的情况下，基类成员在派生类中的访问权限（）。

受限制

保持不变

受保护

不受保护

114.在多继承中，公有派生和私有派生对于基类成员在派生类中的可访问性与单继承的规则（）。

完全相同

完全不同

部分相同，部分不同

以上都不对

115.下面叙述不正确的是（）。

基类的保护成员在派生类中仍然是保护的成员

基类的保护成员在公有派生类中仍然是保护的

基类的保护成员在私有派生类中仍然是私有的

对基类成员的访问必须是无二义性的

116.下面描述中，表达错误的是（）

公有继承时基类中的public成员在派生类中仍是public的

公有继承时基类中的private成员在派生类中仍是private的

公有继承时基类中的protected成员在派生类中仍是protected的

私有继承时基类中的public成员在派生类中是private的

117.运用运算符delete删除一个动态对象时（）。

系统首先为该动态对象调用构造函数，再释放其占用的内存

系统首先释放该动态对象占用的内存，再为其调用构造函数

系统首先为该动态对象调用析构函数，再释放其占用的内存系统

首先释放动态对象占用的内存，再为其调用析构函数

118.有如下类声明：

119.classMyBASE{

120.intk;

121.public:

122.voidset（intn）{k=n;}

123.intget（）const{returnk;}

124.};

125.classMyDERIVED:

protectedMyBASE{

126.protected:

127.intj;

128.public:

129.voidset（intm,intn）{MyBASE:

set（m）;j=n;}

130.intget（）const{returnMyBASE:

get（）+j;}

131.};

132.则类MyDERIVED中保护的数据成员和成员函数的个数是（）。

133.有如下类定义：

134.　　classMyBase{

135.　　intk;

136.　　public:

137.　　MyBase（intn=0）:

k（n）{}

138.　　intvalue（）{returnk;}

139.　　};

140.　　classMyDerived:

MyBase{

141.　　intj;

142.　　public;

143.　　MyDerived（inti）:

j（i）{}

144.　　intgetK（）const{returnk;}

145.　　intgetJ（）const{returnj;}

146.　　};

147.　在一个派生类对象结束其生命周期时（）。

先调用派生类的析构函数后调用基类的析构函数

先调用基类的析构函数后调用派生类的析构函数

如果基数没有定义析构函数，则只调用派生类的析构函数

如果派生类没有定义析构函数，则只调用基类的析构函数

148.执行下列语句后的结果为（）.

149.intx=3,y;

150.int*px=&x;

151.y=*px++;

x=3,y=4

x=3,y=3

x=4,y=4

x=3,y不知

48.在用关键字class定义的类中，以下叙述正确的是（）。

在类中，不作特别说明的数据成员均为私有类型

在类中，不作特别说明的数据成员均为公有类型

类成员的定义必须是成员变量定义在前，成员函数定义在后

类的成员定义必须放在类定义体内部

152.有如下程序：

153.＃include

154.classBASE{

155.charc;

156.public:

157.BASE（charn）:

c（n）{}

158.virtual~BASE（）{cout<

159.};

160.classDERIVED:

publicBASE{

161.charc;

162.public:

163.DERIVED（charn）:

BASE（n+1）,c（n）{}

164.~DERIVED（）{cout<

165.};

166.intmain（）

167.{

168.DERIVEDD（’X’）;

169.return0;

170.}

171.执行上面的程序将输出（）。

172.在以下new和delete运算符使用中,错误的是（）.

char*p=newchar[10];delete[]p;

char*p=newchar[5];delete[]p;p=newchar[10];delete[]p;

char*p=newchar;deletep;

char*p=newint[10];deletep;

173.有如下程序：

174.#include

175.usingnamespacestd;

176.classBASE{

177.public:

178.~BASE（）{cout<<"BASE";}

179.};

180.classDERIVED:

publicBASE{

181.public:

182.~DERIVED（）{cout<<"DERIVED";}

183.};

184.intmain（）{DERIVEDx;return0;}

185.执行后的输出结果是（）。

BASE

DERIVED

BASEDERIVED

DERIVEDBASE

186.有如下程序：

187.#include

188.usingnamespacestd;

189.classA{

190.public:

191.A（）{cout<<"A";}};

192.classB{public:

B（）{cout<<"B";}};

193.classC:

publicA{

194.Bb;

195.public:

196.C（）{cout<<"C";}};

197.intmain（）{Cobj;return0;}

198.执行后的输出结果是（）。

CBA

BAC

ACB

ABC

199.有如下程序：

200.#include

201.usingnamespacestd;

202.classA{

203.public:

204.A（inti）{x=i;}

205.voiddispa（）{cout<

206.private:

207.intx;

208.};

209.classB:

publicA{

210.public:

211.B（inti）:

A（i+10）{x=i;}

212.voiddispb（）{dispa（）;cout<

213.private:

214.intx;

215.};

216.intmain（）{

217.Bb

（2）;

218.b.dispb（）;

219.return0;

220.}

221.运行时输出的结果是

10,2

12,10

12,2

2,2

222.用new运算符创建一维数组的正确形式是（）.

int*p=newa[10];

float*p=newfloat[10];

int*p=newint[10]={0};

int*p=newint[5]={1,2,3,4,5,6};

223.有如下程序：

224.#include

225.usingnamespacestd;

226.classA

227.{

228.public:

229.A（）{cout<<"A";}

230.~A（）{cout<<"~A";}

231.};

232.classB:

publicA

233.{

234.A*p;

235.public:

236.B（）{cout<<"B";p=newA（）;}

237.~B（）{cout<<"~B";deletep;}

238.};

239.intmain（）

240.{

241.Bobj;

242.return0;

243.}

244.执行这个程序的输出结果是

BAA~A~B~A

ABA~B~A~A

BAA~B~A~A

ABA~A~B~A

49.重载运算符的实质是函数调用,如果重载了后置单目运算符“++”,执行C++,则相当于执行了哪个函数（）

c.operator++（c,0）

c.operator++（）

operator++（）

operator++（c,0）

245.应在下列程序划线处填入的正确语句是（）

246.#include

classBase{　

public:

voidfun（）{cout<<"Base:

fun"<

};

classDerived:

publicBase{　

voidfun（）

{_____________//显示调用基类的函数fun（）

cout<<"Derived:

fun"<

}

};

fun（）;

Base.fun（）;

Base:

fun（）;

Base->fun（）;

247.有如下程序

248.　#include

249.　#include

250.　usingnamespacestd;

251.　classMyClass{

252.　public:

253.　　MyClass（）{cout<<’A’;}

254.　　MyClass（charc）{cout<

255.　　~MyClass（）{cout<<’B’;}

256.　　};

257.　voidmain（）{

258.　　MyClassp1,*p2;

259.　　p2=newMyClass（’X’）;

260.　　deletep2;}

261.执行这个程序幕上将显示输出______。

ABX

ABXB

AXB

AXBB

262.有如下程序：

263.#include

264.usingnamespacestd;

265.classPoint{

266.public:

267.staticintnumber;

268.public:

269.Point（）{number++;}

270.~Point（）{number--;}

271.};

272.intPoint:

number=0;

273.voidmain（）{

274.Point*ptr;

275.PointA,B;

276.Point*ptr_point=newPoint[3];

277.ptr=ptr_point;

278.PointC;

279.cout<

number<

280.delete[]ptr;

281.}运行时输出的结果是

282.以下程序的运行结果是______。

283.#include"stdio.h"

284.main（）{

285.inta[]={1,2,3,4,5,6,7,8,9,10,11,12};

286.int*p=a+5,*q＝NULL;

287.*q=*（p+5）;

288.cout<<*p<<*q;}

运行后报错

612

289.有如下程序：

290.#include

291.usingnamespacestd;

292.classTest{

293.public:

294.Test（）{n+=2;}

295.~Test（）{n-=3;}

296.staticintgetNum（）{returnn;}

297.private:

298.staticintn;

299.};

300.intTest:

n=1;

301.intmain（）

302.{

303.Test*p=newTest;

304.deletep;

305.cout<<"n="<

getNum（）<

306.return0;

307.}

308.执行后的输出结果是（）。

n=0

n=1

n=2

n=3

309.以下程序段的输出结果是（）.

310.char*alp[]={"ABC","DEF","GHI"};intj;cout<

DEF

311.以下程序的输出结果是______。

312.main（）

313.{inti,x[3][3]={9,8,7,6,5,4,3,2,1},*p=&x[1][1];

314.for（i=0;i<4;i+=2）cout<

315.}

316.以下程序的输出结果是（）.

317.#includevoidmain（）{chars[]="123",*p;p=s;cout<<*p++<

123

321

318.以下程序的输出结果是（）。

319.#include

320.voidmain（）{

321.chars[]="12134211",*p;

322.intv1=0,v2=0,v3=0,v4=0;

323.for（p=s;*p;p++）

324.switch（*p）{

325.case’1’:

v1++;

326.case’3’:

v3++;

327.case’2’:

v2++;

328.default:

v4++;

329.}

展开阅读全文