C++习题整理2.docx

C++习题整理2.docx

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

C++习题整理2

封装（encapsulation）

封装就是将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。

封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，一特定的访问权限来使用类的成员。

例如，在抽象的基础上，我们可以将时钟的数据和功能封装起来，构成一个时钟类。

按c++的语法，时钟类的声明如下：

class Clock 

{ 

public :

 //共有成员，外部借口 

void SetTime （ int NewH , int NewM , int NewS ） ;

void ShowTime （） ;

private :

 //私有成员，外部无法访问 

int Hour , Minute , Second ;

}

可以看到通过封装使一部分成员充当类与外部的接口，而将其他的成员隐蔽起来，这样就达到了对成员访问权限的合理控制，使不同类之间的相互影响减少到最低限度，进而增强数据的安全性和简化程序的编写工作。

什么是多态（Polymorphisn）？

按字面的意思就是“多种形状”。

引用CharlieCalverts对多态的描述——多态性是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作（摘自“Delphi4编程技术内幕”）。

简单的说，就是一句话：

允许将子类类型的指针赋值给父类类型的指针。

多态性在ObjectPascal和C++中都是通过虚函数（VirtualFunction）实现的。

好，接着是“虚函数”（或者是“虚方法”）。

虚函数就是允许被其子类重新定义的成员函数。

而子类重新定义父类虚函数的做法，称为“覆盖”（override），或者称为“重写”。

“继承”是面向对象软件技术当中的一个概念。

如果一个类A继承自另一个类B，就把这个A称为“B的子类”，而把B称为“A的父类”。

继承可以使得子类具有父类的各种属性和方法，而不需要再次编写相同的代码。

在令子类继承父类的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类的原有属性和方法，使其获得与父类不同的功能。

继承是指一个对象直接使用另一对象的属性和方法。

事实上，我们遇到的很多实体都有继承的含义。

例如，若把汽车看成一个实体，它可以分成多个子实体，如：

卡车、公共汽车等。

这些子实体都具有汽车的特性，因此，汽车是它们的“父亲”，而这些子实体则是汽车的“孩子”。

多继承时很容易产生命名冲突，即使我们很小心地将所有类中的成员变量和成员函数都命名为不同的名字，命名冲突依然有可能发生，比如非常经典的菱形继承层次。

如下图所示：

类A派生出类B和类C，类D继承自类B和类C，这个时候类A中的成员变量和成员函数继承到类D中变成了两份，一份来自A-->B-->D这一路，另一份来自A-->C-->D这一条路。

在一个派生类中保留间接基类的多份同名成员，虽然可以在不同的成员变量中分别存放不同的数据，但大多数情况下这是多余的：

因为保留多份成员变量不仅占用较多的存储空间，还容易产生命名冲突，而且很少有这样的需求。

为了解决这个问题，C++提供了虚基类，使得在派生类中只保留间接基类的一份成员。

声明虚基类只需要在继承方式前面加上 virtual 关键字，请看下面的例子：

#include

usingnamespacestd;

classA{

protected:

inta;

public:

A（inta）:

a（a）{}

};

classB:

virtualpublicA{//声明虚基类

protected:

intb;

public:

B（inta,intb）:

A（a）,b（b）{}

};

classC:

virtualpublicA{//声明虚基类

protected:

intc;

public:

C（inta,intc）:

A（a）,c（c）{}

};

classD:

virtualpublicB,virtualpublicC{//声明虚基类

private:

intd;

public:

D（inta,intb,intc,intd）:

A（a）,B（a,b）,C（a,c）,d（d）{}

voiddisplay（）;

};

voidD:

:

display（）{

cout<<"a="<

cout<<"b="<

cout<<"c="<

cout<<"d="<

}

intmain（）{

（newD（1,2,3,4））->display（）;

return0;

}

#include

#include

main（）

{

inti,x;

scanf（"%d",&x）;

for（i=2;i<=x-1;i++）

if（x%i==0）

printf（"NO\n"）;

for（i=2;i<=x/2;i++）

for（i=2;i<=sqrt（x）;i++）;

}

Virtual是C++OO机制中很重要的一个关键字。

只要是学过C++的人都知道在类Base中加了Virtual关键字的函数就是虚拟函数（例如函数print），于是在Base的派生类Derived中就可以通过重写虚拟函数来实现对基类虚拟函数的覆盖。

当基类Base的指针point指向派生类Derived的对象时，对point的print函数的调用实际上是调用了Derived的print函数而不是Base的print函数。

这是面向对象中的多态性的体现。

（关于虚拟机制是如何实现的，参见InsidetheC++ObjectModel，AddisonWesley1996）

classBase

{

public:

Base（）{}

public:

      virtualvoidprint（）{cout<<"Base";}

};

classDerived:

publicBase

{

public:

Derived（）{}

public:

      voidprint（）{cout<<"Derived";}

};

intmain（）

{

      Base*point=newDerived（）;

      point->print（）;

}

Output：

Derived 

这也许会使人联想到函数的重载，但稍加对比就会发现两者是完全不同的：

（1）      重载的几个函数必须在同一个类中；

覆盖的函数必须在有继承关系的不同的类中

（2）      覆盖的几个函数必须函数名、参数、返回值都相同；

重载的函数必须函数名相同，参数不同。

参数不同的目的就是为了在函数调用的时候编译器能够通过参数来判断程序是在调用的哪个函数。

这也就很自然地解释了为什么函数不能通过返回值不同来重载，因为程序在调用函数时很有可能不关心返回值，编译器就无法从代码中看出程序在调用的是哪个函数了。

（3）      覆盖的函数前必须加关键字Virtual；

重载和Virtual没有任何瓜葛，加不加都不影响重载的运作。

第6题（1.0分）

C语言把文件看作是一个【1】的序列.

答案：

=======（答案1）=======

字符

=========或=========

字节

第7题（1.0分）

静态变量和外部变量的初始化是在【1】阶段完成的,而自动变量的赋值是

在【2】时进行的.

答案：

=======（答案1）=======

编译

=======（答案2）=======

函数调用

第8题（1.0分）

若有定义:

inta[3][2]={2,4,6,8,10,12};,则*（a[1]+1）的值是【1】.

答案：

=======（答案1）=======

8

第9题（1.0分）

C语言中,数组名是一个不可变的【1】量,不能对它进行加减和赋值运算.

答案：

=======（答案1）=======

地址

第12题（1.0分）

feof（fp）函数用来判断文件是否结束,如果遇到文件结束,函数值为【1】,

否则为【2】.

答案：

=======（答案1）=======

非0值

=======（答案2）=======

0

第13题（1.0分）

如果函数不要求带回值,可用【1】来定义函数返回值为空.

答案：

=======（答案1）=======

void

第14题（1.0分）

调用fopen函数打开一文本文件,在"使用方式"这一项中,

为输出而打开需填入【1】.

答案：

=======（答案1）=======

w

=========或=========

w+

第15题（1.0分）

顺序结构存储方法是把逻辑上相邻的结点存储在物理位置【1】

的存储单元中。

答案：

=======（答案1）=======

相邻

第16题（1.0分）

一个类可以从直接或间接的祖先中继承所有属性和方法。

采用

这个方法提高了软件的【1】。

答案：

=======（答案1）=======

可重用性

第17题（1.0分）

C++中封装性、继承性和【1】是面向对象程序设计的三个主要性质。

答案：

=======（答案1）=======

多态性

第18题（1.0分）

C++语言的参数传递机制包括传值和传地址两种，如果调用函数

时，需要改变实参或者返回多个值，应该采取【1】方式。

答案：

=======（答案1）=======

传地址

第19题（1.0分）

设i，j，k均为int型变量，则执行完for（i=0,j=10;j<=j;i++,j--）k=i+j;

语句后，K的值为【1】。

答案：

=======（答案1）=======

10

第20题（1.0分）

对长度为10的线性表进行冒泡排序，最坏情况下需要比较的次数为【1】。

答案：

=======（答案1）=======

45

二、判断共20题（共计20分）

第1题（1.0分）

用fopen（"file","r+"）;打开的文件"file"可以进行修改。

答案：

Y

第2题（1.0分）

inti=20;switch（i/10）{case2:

printf（"A"）;

case1:

printf（"B"）;}的输出结果为A。

答案：

N

第3题（1.0分）

若有定义和语句：

inta;charc;floatf;scanf（"%d,%c,%f",&a,&c,&f）;

若通过键盘输入：

10,A,12.5,则a=10,c='A',f=12.5.

答案：

Y

第4题（1.0分）

char*p="girl";的含义是定义字符型指针变量p，p的值是字符串"girl"。

答案：

N

第5题（1.0分）

x*=y+8等价于x=x*（y+8）。

答案：

Y

第6题（1.0分）

如果有一个字符串，其中第十个字符为'\n'，则此字符串的

有效字符为9个。

答案：

N

第7题（1.0分）

通过return语句，函数可以带回一个或一个以上的返回值。

答案：

N

第8题（1.0分）

如果想使一个数组中全部元素的值为0，可以写成

inta[10]={0*10};

答案：

N

第9题（1.0分）

一个include命令可以指定多个被包含的文件。

答案：

N

第10题（1.0分）

C程序中有调用关系的所有函数必须放在同一个源程序文件中。

答案：

N

第11题（1.0分）

进行宏定义时，宏名必须使用大写字母表示。

答案：

N

第12题（1.0分）

共同体变量所占的内存长度等于最长的成员的长度。

答案：

Y

第13题（1.0分）

在C语言中，此定义和语句是合法的：

enumaa{a=5,b,c}bb;bb=（enumaa）5;

答案：

Y

第14题（1.0分）

7&3+12的值是15。

答案：

N

第15题（1.0分）

类有两个特殊的成员函数构造函数和虚函数

答案：

N

第16题（1.0分）

抽象类不仅可用做派生其他类的基类，也可以用于直接创建对象

实例。

答案：

N

第17题（1.0分）

静态函数可声明为虚函数。

答案：

N

第18题（1.0分）

如果一个函数在其函数体内直接或间接的调用了自己，该函数

称为递归函数。

答案：

Y

第19题（1.0分）

类中提供了三种访问控制权：

公有、私有、保护三种类型。

答案：

Y

第20题（1.0分）

所谓继承就是利用已有的数据类型定义出新的数据类型。

答案：

Y

三、单选共60题（共计60分）

第1题（1.0分）

fscanf函数的正确调用形式是（）。

A:

fscanf（fp,格式字符串,输出表列）;

B:

fscanf（格式字符串,输出表列,fp）;

C:

fscanf（格式字符串,文件指针,输出表列）;

D:

fscanf（文件指针,格式字符串,输入表列）;

答案：

D

第2题（1.0分）

C语言的if语句嵌套时，if与else的配对关系是（）。

A:

每个else总是与它上面的最近的if配对

B:

每个else总是与最外层的if配对

C:

每个else与if的配对是任意的

D:

每个else总是与它上面的if配对

答案：

A

第3题（1.0分）

C语言中，文件由（）。

A:

记录组成

B:

由数据行组成

C:

由数据块组成

D:

由字符（字节）序列组成

答案：

D

第4题（1.0分）

设C语言中，int类型数据占2个字节，则short类型数据占（）。

A:

1个字节

B:

2个字节

C:

4个字节

D:

8个字节

答案：

B

第5题（1.0分）

以下不符合C语言语法的赋值语句是（）。

A:

j++;

B:

j=j=5;

C:

k=2*4,k*4;

D:

y=float（j）;

答案：

D

第6题（1.0分）

C语言允许函数类型缺省定义，此时函数值隐含的类型是（）。

A:

float

B:

int

C:

long

D:

double

答案：

B

第7题（1.0分）

int（*p）[6];它的含义为（）。

A:

具有6个元素的一维数组

B:

定义了一个指向具有6个元素的一维数组的指针变量

C:

指向整型指针变量

D:

指向6个整数中的一个的地址

答案：

B

第8题（1.0分）

经下列语句定义后，sizeof（x），sizeof（y），sizeof（a），sizeof（b）在

微机上的值分别为（）。

charx=65;

floaty=7.3;

inta=100;

doubleb=4.5;

A:

2,2,2,4

B:

1,2,2,4

C:

1,4,2,8

D:

2,4,2,8

答案：

C

第9题（1.0分）

char*match（charc）是（）。

A:

函数定义的头部

B:

函数预说明

C:

函数调用

D:

指针变量说明

答案：

A

第10题（1.0分）

若有说明:

inta[3][4]={0};则下面正确的叙述是（）。

A:

只有元素a[0][0]可得到初值0

B:

此说明语句不正确

C:

数组a中各元素都可得到初值,但其值不一定为0

D:

数组a中每个元素均可得到初值0

答案：

D

第11题（1.0分）

当说明一个结构体变量时系统分配给它的内存是（）。

A:

各成员所需内存量的总和

B:

结构中第一个成员所需内存量

C:

成员中占内存量最大者所需的容量

D:

结构中最后一个成员所需内存量

答案：

A

第12题（1.0分）

以下不是无限循环的语句为（）。

A:

for（y=0,x=1;x>++y;x=i++）i=x;

B:

for（;;x++=i）;

C:

while

（1）{x++;}

D:

for（i=10;;i--）sum+=i;

答案：

A

第13题（1.0分）

利用fseek函数可以实现的操作是（）。

A:

改变文件的位置指针

B:

文件的顺序读写

C:

文件的随机读写

D:

以上答案均正确

答案：

D

第14题（1.0分）

C语言中while和do-while循环的主要区别是（）。

A:

do-while的循环体至少无条件执行一次

B:

while的循环控制条件比do-while的循环控制条件更严格

C:

do-while允许从外部转到循环体内

D:

do-while的循环体不能是复合语句

答案：

A

第15题（1.0分）

sizeof（float）是（）。

A:

一种函数调用

B:

一个不合法的表达式

C:

一个整型表达式

D:

一个浮点表达式

答案：

C

第16题（1.0分）

以下程序的运行结果是（）。

main（）

{intn;

for（n=1;n<=10;n++）

{

if（n%3==0）continue;

printf（"%d",n）;

}

}

A:

12457810

B:

369

C:

12

D:

1234567890

答案：

A

第17题（1.0分）

以下不正确的叙述是（）。

A:

在C程序中所用的变量必须先定义后使用

B:

程序中，APH和aph是两个不同的变量

C:

若a和b类型相同，在执行了赋值语句a=b；后b中的值将放入a中，b中的值不变

D:

当输入数值数据时，对于整型变量只能输入整型值；对于实型变量只能输入实型值

答案：

D

第18题（1.0分）

下列程序的输出结果为（）。

main（）

{intm=7,n=4;

floata=38.4,b=6.4,x;

x=m/2+n*a/b+1/2;

printf（"%f\n",x）;

}

A:

27.000000

B:

27.500000

C:

28.000000

D:

28.500000

答案：

A

第19题（1.0分）

凡是函数中未指定存储类别的局部变量，其隐含的存储类别为（）。

A:

自动（auto）

B:

静态（static）

C:

外部（extern）

D:

寄存器（register）

答案：

A

第20题（1.0分）

下列定义数组的语句中正确的是（）。

A:

#definesize10charstr1[size],str2[size+2];

B:

charstr[];

C:

intnum['10'];

D:

intn=5;inta[n][n+2];

答案：

A

第21题（1.0分）

以下描述中，正确的是（）。

A:

预处理是指完成宏替换和文件包含中指定的文件的调用

B:

预处理指令只能位于C源文件的开始

C:

C源程序中凡是行首以#标识的控制行都是预处理指令

D:

预处理就是完成C编译程序对C源程序第一遍扫描,为编译词法和语法分析作准备

答案：

C

第22题（1.0分）

位字段数据的单位是（）位。

A:

十六进制

B:

八进制

C:

二进制

D:

十进制

答案：

C

第23题（1.0分）

以下的选择中，正确的赋值语句是（）。

A:

a=1,b=2

B:

j++

C:

a=b=5;

D:

y=int（x）

答案：

C

第24题（1.0分）

若有int*p=（int*）malloc（sizeof（int））;则向内存申请到内存

空间存入整数123的语句为（）。

A:

scanf（"%d",p）;

B:

scanf（"%d",&p）;

C:

scanf（"%d",*p）;

D:

scanf（"%d",**p）;

答案：

A

第25题（1.0分）

已知大写字母A的ASCII码值是65，小写字母a的ASCII码是97，则用

八进制表示的字符常量'\101'是（）。

A:

字符A

B:

字符a

C:

字符e

D:

非法的常量

答案：

A

第26题（1.0分）

以下叙述中正确的是（）。

A:

C程序中注释部分可以出现在程序中任意合适的地方

B:

花括号“{“和”}”只能作为函数体的定界符

C:

构成C程序的基本单位是函数,所有函数名都可以由用户命名

D:

分号是C语句之间的分隔符,不是语句的一部分

答案：

A

第27题（1.0分）

假定int类型变量占用两个字节，其有定义:

intx[10]={0,2,4};，

则数组x在内存中所占字节数是（）。

A:

3

B:

6

C:

10

D:

20

答案：

D

第28题（1.0分）

在C语言中，形参的缺省存储类是（）。

A:

auto

B:

register

C:

static

D:

extern

答案：

A

第29题（1.0分）

已知字母a的ASCII十进制代码为97，则执行下列语句后的输出结果为（）。

chara='a';a--;

printf（"%d,%c\n",a+'2'-'0',a+'3'-'0'）;

A:

b,c

B:

a--运算不合法,故有语法错

C:

98,c

D:

格式描述和输出项不匹配,输出无定值

答案：

C

第30题（1.0分）

不仅可将C源程序存在磁盘上，还可将数据按数据类型分别以什么的

形式存在磁盘上（）。

A:

内存

B:

缓冲区

C:

文件

D:

寄存器

答案：

C

第31题（1.0分）

表达式18/4*sqrt（4.0）/8值的数据类型为（）。

A:

int

B:

float

C:

double

D:

不确定

答案：

C

第32题（1.0分）

以下能对二维数组a进行正确初始化的语句是（）。

A:

inta[2][]={{1,0,1},{5,2,3}};

B:

inta[][3]={{1,2,3},{4,5,6}};

C:

inta[2][4]={{1,2,3},{4,5},{6}};

D:

inta[][3]={{1,0,1}{},{1,1}};

答案：

B

第33题（1.0分）

函数rewind的作用是（）。

A:

使位置指针重新返回文件的开头

B:

将位置指针指向文件中所要求的特定位置

C:

使位置指针指向文件的末尾

D:

使位置指针自动移至下一个字符位置

答案：

A

第34题（1.0分）

在C语言中，要求运算数必须是整型或字符型的运算符是（）。

A:

&&

B:

&

C:

!

D:

||

答案：

B

第35题（1.0分）

inta=1,b=2,c=3;

if（a>c）b=a;a=c;c=b;则c的值为（）。

A:

1

B:

2

C:

3

D:

不一定

答案：

B

第36题（1.0分）

对for（表达式1;;表达式3）可理解为（）。

A:

for（表达式1;0;表达式3）

B:

for（表达式1;1;表达式3）

C:

for（表达式1;表达式1;表达式3）

D:

for（表达式1;表达式3;表达式3）

答案：

B

第37题（1.0分）

a,b为整型变量，二者均不为0，以下关系表达式中恒成立的是（）。

A:

a*b/a*b==1

B:

a/b*b/a=