中国大学MOOC 面向对象程序设计(C++…

文章目录[隐藏]

第一部分面向对象方法与C++概述
第二部分过程化编程技术-函数应用
第三部分封装与信息隐藏-类与对象
第四部分面向对象编程技术-继承与派生
第五部分面向对象编程技术-多态性
面向对象程序设计期中考试
面向对象程序设计期末综合测评

第一部分面向对象方法与C++概述

1 在下面的一维数组定义中，（）语句有语法错误
喵查答案：正确
int a[ ]={1,2,3};
错误
int a[10]={0};
喵查答案：int a[ ];
int a[5];

2 由C++源程序文件编译而成的目标文件的缺省扩展名为( )
正确
.obj
喵查答案：错误
.lik
.exe
喵查答案：.cpp

3 下列哪个是 C++语言中有效标识符( )
庄园
12345
柱廊园
No.1
喵查答案：文人园
喵查答案： _No1
公共园林
int

4 关于C++语言和C语言的关系的下列描述中，错误的是( )
C语言是C++语言的一个子集
喵查答案：正确
喵查答案：C语言和C++语言都是面向对象的语言
错误
C++语言与C语言兼容
C++语言对C语言做了些改进

5 在C++中，数据封装要解决的问题是( )
数据的规范化
便于数据转换
避免数据丢失
喵查答案：防止不同模块之间数据的非法访问

6 返回类型就是函数返回结果值的数据类型。返回类型可以是（）
除数组和类以外的任意数据类型

除数组和结构类型以外的任意数据类型

喵查答案：

除数组类型以外的任意数据类型

除指针和引用类型以外的任意数据类型

第二部分过程化编程技术-函数应用

1 关于内联函数的说法不正确的是____
在说明类的同时定义成员函数，则函数隐含为内联函数
也可在类外用inline关键字，对成员函数进行说明，则该函数也为内联函数
当内联函数被调用时，内联函数的代码在调用处被打开
喵查答案：当内联函数被调用时，内联函数将返回结果

2 以下说法中正确的是____
C++语言程序总从第一个的函数开始执行
在C++语言程序中，要调用的函数必须在main( )函数中定义
喵查答案：C++语言程序总是从main( )函数开始执行
C++语言程序中的main( )函数必须放在程序的开始部分

3 决定C++语言中函数的返回值类型的是____
return语句中的表达式类型
调用该函数时系统随机产生的类型
调用该函数时的主调用函数类型
喵查答案：在定义该函数时所指定的数据类型

4 在C++中，函数原型不能标识____
函数的返回类型
函数参数的个数
函数参数类型
喵查答案：函数的功能

5 下列函数的声明正确的是____
float sum(float x,y) {…….}
喵查答案：flaot sum(float,float );
float sum(x,y)
float sum(floatx,floaty) {…….}

6 关于函数的调用下面不正确的是____
一个函数可以自己调用自己
函数的调用可以在任意函数之间进行，只要有需要
喵查答案：由于程序总是从主函数开始，所以函数的调用总是在主函数和其他函数之间进行
函数返回时可以不必带返回值，这时函数在定义时其类型应用void标示

7 下面关于C++语言说法不正确的是____
喵查答案：具有函数式的程序结构，其程序至少由一个函数构成，不论是主函数，还是其他函数
变量的数据类型丰富，而且使用不同的存储类别，以控制函数内外信息的交换
具有编译预处理的功能，为程序的设计与修改、调试、移植带来方便
既是面向结构的程序设计语言，又是面向对象的程序设计语言，使用起来很方便

以下函数值的类型是____。fun(float x){ float y; y=3*x-4; return(y);}
喵查答案：int
char
void
float

9 在调用函数时，如果实参是简单变量，它与对应形参之间的数据传递方式是____
地址传递
喵查答案：单向值传递
由实参传给形参，再由形参传回实参
传递方式由用户指定

10 关于函数的返回不正确的是____
使程序的执行重新返回到主函数，使程序继续往下执行
释放调用函数时临时分配的存储单元
喵查答案：返回一个值给主调函数
其返回值可为数值、地址，也可没有任何返回值

11 下列关于C++函数的描述中正确的是____。
主函数是程序的入口，它由用户定义的函数调用
喵查答案：函数在调用之前必须先被声明
每个用户定义函数只能被其他函数调用一次
函数是C++中面向对象程序设计框架的基本组成单元

12 下列函数原型声明中错误的是____。
void Fun(int x=0,int y=0);
void Fun(int x,int y);
void Fun(int x,int y=0);
喵查答案：void Fun(int x=0,int y);

1 在编译指令中，宏定义使用哪个指令（）。
#include
喵查答案：#define
#if
#else

2 在C++中使用流进行输入输出，其中用于屏幕输出的对象是（）。
cerr
cin
cfile
喵查答案：cout

3 设存在函数int max(int，int)返回两参数中较大值，若求22，59，70中最大值，下列表达式不正确的是（）。

int m = max(22，max(59，70))

int m = max(max(22，59)，70)
喵查答案：int m = max(22，59，70)
int m = max(59，max(22，70))

4 在函数调用时，如某一默认参数要指明一个特定值，则有（）。
喵查答案：

其之前所有参数都必须赋值

其之后所有参数都必须赋值
其前、后所有参数都必须赋值
其前、后所有参数都不必赋值

5 在一个被调用函数中，关于return语句使用的描述，（）是错误的。

被调用函数中可以不用return语句

被调用函数中可以使用多个return语句

被调用函数中，如果有返回值，就一定要有return语句
喵查答案：被调用函数中，一个return语句可以返回多个值给调用函数

6 对于C/C++语言的函数，下列叙述中正确的是（）。

函数的定义可以嵌套，但函数调用不能嵌套
喵查答案：函数的定义不能嵌套，但函数调用可以嵌套

函数的定义和调用都不能嵌套
函数的定义和调用都可以嵌套

7 当一个函数无返回值时,定义它的函数的类型是（）。
int
无
喵查答案：void
long

8 在函数原型说明中，不是必要的。
喵查答案：函数参数名

9 面向对象的程序设计有四大特征，它们是抽象、、继承、多态。
喵查答案：封装

10 下面是一个输入半径，输出其面积和周长的C++程序，在下划线处填上正确的语句。#include using namespace std； const double pi=3.14159； void main( ) { double r； cout<<″r=″； ; double l=2.0*pi*r； double s=pi*r*r； cout<<″＼n The long is：″<<l<<endl； cout<<″The area is：″<<s<<endl； }
喵查答案：cin>>r

11 C++语言中可以实现输出一个换行符并刷新流功能的操控符是。
喵查答案：endl

12 要把一个文件输出流对象myFile与文件“f：\myText.txt相关联，所用的C++语句是。
喵查答案：myFile.open(“f:\\myText.txt”)

1 下列说法正确的是（）
喵查答案：若“a=5.4,b=4”则执行“(int )(a/b,a++)”后a的值为6
运算符*的优先级要低于sizeof的优先级
已知“a=4,b=5,max=(++a<b++)?a++:++b”则max的值为5
“a=1;b=5;–a&&b++;”执行后b的值为5

2 下列字符常量的写法中，错误的是（）
喵查答案：

’\4f’

’\105′

’*’

’\a’

3 对象的封装就是（）
喵查答案：可进可出，但是外界不能干涉内部的处理过程
与世隔绝
只进不出
封装只是抽象的封装，外界可以直接干预

4 对于函数 put() 的说法不正确的是（）
喵查答案：它的功能是输出字符串并换行
其参数可以是字符常量
其参数可以是字符变量
将字符送入输出流

5 关于getline函数的说法不正确的是（）
喵查答案：该函数是接收字符串的函数
该函数接收的字符串长度是受限的，可以人为设置所接收字符串的长度，它所接收的字符串长度是这一长度值减1
该函数遇到换行符或其他终止符后结束操作
该函数接收从键盘输入的字符串

6 下面程序的输出结果是（）#includeusing std::cout; using std::endl;templatet max (t a,t b){return (a>=b)?a:b;}int main( ){ cout<<max(5,8)<<endl; cout<<max("zhangsan","lisi");}
喵查答案：

lisi

zhangsan

lisi

7 关于静态数据成员的说法正确的是（）
喵查答案：静态数据成员是所有同类的对象共享数据，它不能具体地属于哪一个对象
静态数据成员虽然能实现同类的对象共享数据，但破坏了类的封装性
静态数据成员只在类中声明一次即可
若C为一个类，a为它的一个对象，s为类中的一个静态数据成员，则static int a.s 可以说明s为一个静态数据成员

8 关于内联函数的说法不正确的是（）
喵查答案：当内联函数被调用时，内联函数将返回结果
在说明类的同时定义成员函数，则函数隐含为内联函数
也可在类外用inline关键字，对成员函数进行说明，则该函数也为内联函数
当内联函数被调用时，内联函数的代码在调用处被打开

9 下列说法正确的是（）
喵查答案：当字符串放在字符数组中，这时要求字符数组长度比字符串长1个单元，因为要放字符串终结符‘\0’
字符型数组与整型数组可通用
字符型数组与字符串其实没有什么区别
字符串的输出可以用它所存储的数组来输出，也可以字符串的形式整体输出，结果没区别

10 下列一维数组定义正确的是（）
喵查答案：const int x=5;float num[x];
x=5;int num[x];
const float x=5;int num[x];
const int x;x=5;int num[x];

11 下面程序的输出结果是（）#includeusing namespace std;int main( ){ int I,j,m=0,n=0; for(I=0;I<2;I++) for(j=0;j=I) m=1;n++; cout<<m<<endl; cout<<n;}
喵查答案：11
15
16
02

12 下面程序的输出结果是（）#includeusing namespace std;int main(){ int s; for(int k=2;k<6;k+=2){ s=1; for(int j=k;j<6;j++)s+=j; }cout<<s<<endl;}
喵查答案：10
9
1
11

13 下面说法不正确的是（）
喵查答案：数组名作形参时，形参改变不会影响实参值
数组元素作为函数参数属于值传递
数组名作为函数参数属于地址传递，形参、实参共用同一内存空间
数组元素作形参时，形参改变不会影响实参值

14 有定义“int a[2][5];”若a[0][1]的地址为x,则a[0][0]、a[1][3]地址分别为（假设一个整型数据占用两个字节的内存空间）（）
喵查答案：

x-2, x+14

x-1, x+7

x+1, x+7

x-1, x+14

15 下面程序的输出结果是（）#includeusing namespace std;int main( ){ int a,b; for(a=1,b=1;a=10) break; if(b%3==1) {b+=3;continue;} }cout<<a;}
喵查答案：4
5
6
11

16 下列语句段将输出字符’*’的个数为（）int i=100;while(1){ i–; if(i==0)break; cout<<'*'; }
喵查答案：99个
98个
101个
100个

17 下列运算结果正确的是（）
喵查答案：“y=x++;”可以写成“y=x;x=x+1;”,“y=++x;”可以写成“x=x+1;y=x;
“const y;int x=2;y=x++;”执行后值为3
“const y=2;int x=3;x++=y;”执行后，i的值为2
“int x,y;y=(x=5,x++,x+2);”执行后x值为8

18 已知枚举类型定义语句为：enum Token { NAME,NUMBER,PLUS=5,MINUS,PRINT=10};则下列说法中错误的是（）
喵查答案：

枚举常量NAME的值为1

枚举常量NUMBER的值为1

枚举常量MINUS的值为6

枚举常量PRINT的值为10

19 C++是（）
喵查答案：

既是面向对象的程序设计语言又是结构化程序设计语言

面向对象的程序设计语言

结构化程序设计语言

非结构化程序设计语言

下列C++标点符号中表示一条预处理命令开始的是（ )

喵查答案：

;

}

21 下列说法正确的是（）
喵查答案：若“a=5.4,b=4”则执行“(int )(a/b,a++)”后a的值为6
运算符*的优先级要低于sizeof的优先级
已知“a=4,b=5,max=(++a<b++)?a++:++b”则max的值为5
“a=1;b=5;–a&&b++;”执行后b的值为5

22 下列字符常量的写法中，错误的是（）
喵查答案：

’\4f’

’\105′

’*’

’\a’

23 对象的封装就是（）
喵查答案：可进可出，但是外界不能干涉内部的处理过程
与世隔绝
只进不出
封装只是抽象的封装，外界可以直接干预

24 对于函数 put() 的说法不正确的是（）
喵查答案：它的功能是输出字符串并换行
其参数可以是字符常量
其参数可以是字符变量
将字符送入输出流

25 关于getline函数的说法不正确的是（）
喵查答案：该函数是接收字符串的函数
该函数接收的字符串长度是受限的，可以人为设置所接收字符串的长度，它所接收的字符串长度是这一长度值减1
该函数遇到换行符或其他终止符后结束操作
该函数接收从键盘输入的字符串

26 下面程序的输出结果是（）#includeusing std::cout; using std::endl;templatet max (t a,t b){return (a>=b)?a:b;}int main( ){ cout<<max(5,8)<<endl; cout<<max("zhangsan","lisi");}
喵查答案：

lisi

zhangsan

lisi

27 关于静态数据成员的说法正确的是（）
喵查答案：静态数据成员是所有同类的对象共享数据，它不能具体地属于哪一个对象
静态数据成员虽然能实现同类的对象共享数据，但破坏了类的封装性
静态数据成员只在类中声明一次即可
若C为一个类，a为它的一个对象，s为类中的一个静态数据成员，则static int a.s 可以说明s为一个静态数据成员

28 关于内联函数的说法不正确的是（）
喵查答案：当内联函数被调用时，内联函数将返回结果
在说明类的同时定义成员函数，则函数隐含为内联函数
也可在类外用inline关键字，对成员函数进行说明，则该函数也为内联函数
当内联函数被调用时，内联函数的代码在调用处被打开

29 下列说法正确的是（）
喵查答案：当字符串放在字符数组中，这时要求字符数组长度比字符串长1个单元，因为要放字符串终结符‘\0’
字符型数组与整型数组可通用
字符型数组与字符串其实没有什么区别
字符串的输出可以用它所存储的数组来输出，也可以字符串的形式整体输出，结果没区别

30 下列一维数组定义正确的是（）
喵查答案：const int x=5;float num[x];
x=5;int num[x];
const float x=5;int num[x];
const int x;x=5;int num[x];

31 下面程序的输出结果是（）#includeusing namespace std;int main( ){ int I,j,m=0,n=0; for(I=0;I<2;I++) for(j=0;j=I) m=1;n++; cout<<m<<endl; cout<<n;}
喵查答案：11
15
16
02

32 下面程序的输出结果是（）#includeusing namespace std;int main(){ int s; for(int k=2;k<6;k+=2){ s=1; for(int j=k;j<6;j++)s+=j; }cout<<s<<endl;}
喵查答案：10
9
1
11

33 下面说法不正确的是（）
喵查答案：数组名作形参时，形参改变不会影响实参值
数组元素作为函数参数属于值传递
数组名作为函数参数属于地址传递，形参、实参共用同一内存空间
数组元素作形参时，形参改变不会影响实参值

34 有定义“int a[2][5];”若a[0][1]的地址为x,则a[0][0]、a[1][3]地址分别为（假设一个整型数据占用两个字节的内存空间）（）
喵查答案：

x-2, x+14

x-1, x+7

x+1, x+7

x-1, x+14

35 下面程序的输出结果是（）#includeusing namespace std;int main( ){ int a,b; for(a=1,b=1;a=10) break; if(b%3==1) {b+=3;continue;} }cout<<a;}
喵查答案：4
5
6
11

36 下列语句段将输出字符’*’的个数为（）int i=100;while(1){ i–; if(i==0)break; cout<<'*'; }
喵查答案：99个
98个
101个
100个

37 下列运算结果正确的是（）
喵查答案：“y=x++;”可以写成“y=x;x=x+1;”,“y=++x;”可以写成“x=x+1;y=x;
“const y;int x=2;y=x++;”执行后值为3
“const y=2;int x=3;x++=y;”执行后，i的值为2
“int x,y;y=(x=5,x++,x+2);”执行后x值为8

38 已知枚举类型定义语句为：enum Token { NAME,NUMBER,PLUS=5,MINUS,PRINT=10};则下列说法中错误的是（）
喵查答案：

枚举常量NAME的值为1

枚举常量NUMBER的值为1

枚举常量MINUS的值为6

枚举常量PRINT的值为10

39 C++是（）
喵查答案：

既是面向对象的程序设计语言又是结构化程序设计语言

面向对象的程序设计语言

结构化程序设计语言

非结构化程序设计语言

下列C++标点符号中表示一条预处理命令开始的是（ )

喵查答案：

;

}

41 以下说法中正确的是（）
喵查答案：C++语言程序总是从main( )函数开始执行
C++语言程序总从第一个的函数开始执行
在C++语言程序中，要调用的函数必须在main( )函数中定义
C++语言程序中的main( )函数必须放在程序的开始部分

42 下列关于函数的调用，不正确的是（）
喵查答案：函数的调用可作为函数形参
如果一个问题的解决要依靠另一个问题的解决，而另一个问题的解决的方法与原问题相同，则此问题可用递归方法来解决
函数的调用可作为函数的实参
函数的调用可出现在执行语句中，也可出现在表达式中

43 形参与实参的说法正确的是（）
喵查答案：形参与实参的个数、类型、顺序都应一一对应
形参与实参的个数可以不必相同，少一个多一个，程序一样执行
形参与实参的类型可以不同，不影响运算结果
形参与实参的类型个数相同，而顺序不同，计算机可以自动进行匹配，所以形参的顺序无所谓，只要各种形参类型的数量与实参相同即可

44 函数软件就是在程序设计中，把功能相对独立、单一的模块用一个函数实现，再由若干个函数组成完整程序的设计方法。其中的函数叫做软件函数，关于软件函数下列说法不正确的是（）
喵查答案：用全局变量能使每个文件中各个函数保持联系，使函数之间的沟通交往十分方便，因而可以多用全局变量，以加强函数之间的联系
软件函数结构独立，功能单一，便于编写和调试、修改，在结构化程序设计中相当重要
可以并行开发，加快软件开发速度，缩短开发周期
函数的重复使用性好，提高开发效率

45 运行下列程序，输出结果是（）#includeusing namespace std;void fun(int i);int main(){ int n=2; fun(n); return 0;}void fun(int i){ static int x=1; int y=1; if(i>0) { ++x; ++y; cout<<x<<' '<<y<<' '; fun(i-1); }}
喵查答案：2 2 3 2
2 2 2 2
2 2 3 3
语法错，不能输出正确结果

46 下面程序的输出结果是（）#includeusing namespace std;int main( ){ int *p, *q,i=8,j=9; p=&i; q=&j; cout<<*p; *q=i; cout<<*q; q=p; cout<<*q; p=q; cout<<*p;}
喵查答案：8888
8889
8989
8899

47 关于普通变量的说法不正确的是（）
喵查答案：语句“cin>>&a;”表示把某个数据存入变量a
普通变量的数据类型不同则所占内存的字节数量不同
普通变量在赋值函数“＝”的左边、右边的含义不同，在左边表示要存储的数据的地址，在右边表示一个值
有如下定义“int a;”则&a代表变量a所代表数据在内存中的地址

48 下面说法错误的是（）
喵查答案：数组初始化时，若给定元素个数少于数组元素，多余数组元素自动初始化为最后一个给定元素值
一个数组只允许存储同种类型的变量
数组名称其实是数组在内存中的首地址
当数组名作为参数被传递给某个函数时，原数组中元素的值可能被修改

下面程序的输出结果是（）

#include

using namespace std;

int main( )

{ int a=18;

int *p=&a;

cout<<(long)p;}
喵查答案：以十进制输出变量a的地址
以八进制输出变量a的地址
以十进制输出p的地址
以十六进制输出a的地址

包含在iostream文件中，有缓冲区，用来处理标准出错信息的输出的是（）
喵查答案：

clog

cout

cerr

out
pay point=”5″
1

关于宏定义，执行如下的程序段后，判断正确的是（）

#define A 10

#define B(a) (A*A/a)

int main( ){int n=B(A-5); }
n=20
n=4
喵查答案：n=5
程序出错，因为宏定义不能嵌套

2 在int a=3,int *p=&a；中，*p的值是（）

变量a的地址值
无意义
变量p的地址值
喵查答案：3

3 适宜采用inline定义函数情况是（）
函数体含有循环语句
函数体含有递归语句
喵查答案：函数代码少、频繁调用
函数代码多、不常调用

一个交换两个浮点数的函数swap，并在主函数中调用这个函数进行两个浮点数的交换，但结果未正确输出，只修改哪一行代码来使程序正确

Void swap(float a,float b)

{ float temp=a;

a=b;

b=temp; }

void main( )

{ float a=1,b=2;

swap ( a, b ); }
喵查答案：第1行
第2行
第4行
第6行

5 下列有关重载函数的说法中正确的是（）
重载函数必须具有不同的返回值类型
重载函数参数个数必须相同
喵查答案：重载函数必须有不同的形参列表
重载函数名可以不同

6 函数调用func((exp1,exp2),(exp3,exp4,exp5))中所含实参的个数为（）
1
喵查答案：2
4
5

7 C++语言中所有在函数中定义的变量，连同形式参数，都属于（）
全局变量
喵查答案：局部变量
静态变量
函数

int f( )

{ static int a1 = 0;

static int a2 = 1; //change

a1 = a2;

return(a2 += 2 * a1 +1);

}

int main( )

{int i, sum, f( );

for(i = sum = 0; i<5; i++)

{ sum+=f( );

cout<<"sum = "<<sum<<'\n'; }

}

第三行的输出是（）
喵查答案：sum=57

第三部分封装与信息隐藏-类与对象

1 要求打开文件”d:\file.dat”，可写入数据，正确的语句是（）

ifstream infile(“d:\file.dat”, ios::in)；
喵查答案：

ifstream infile(“d:\\file.dat”, ios::in)；

ofstream infile(“d:\file.dat”, ios::out)；
fstream infile(“d:\\file.dat”, ios::in|ios::out)；

2 已知：print( )函数是一个类的常成员函数，它无返回值，下列表示中，是正确的（）
喵查答案：

void print( ) const；

const void print( )；

void const print( )：

void print(const)；

3 下列说明中 const char *ptr；其中 ptr 应该是（）

指向字符常量的指针

指向字符的常量指针
喵查答案：指向字符串常量的指针
指向字符串的常量指针

4 作用域运算符“：：”的功能是（）

标识作用域的级别的
喵查答案：

指出作用域的范围的
给定作用域的大小的
标识成员是属于哪个类的

5 下列的各类函数中，不是类的成员函数（）
构造函数
析构函数
喵查答案：友元函数
拷贝初始化构造函数

6 不能作为函数重载依据的是( )
const
喵查答案：返回类型
参数个数
参数类型

7 有如下程序：#include using namespace std;class VAC{public: int f() const{return 3;} int f(){return 5;}};int main(){ VAC v1; const VAC v2; cout<<v1.f()<<v2.f(); return 0;}运行时的输出结果是（）
喵查答案：

35
55
33

8 有如下类的定义：class Constants{public: static double GetPI(void){return 3.14159;}};Constants constants;下列各组语句中，能输出3.14159的是（）

cout<GetPI( );和cout<<Constants::GetPI( );
喵查答案：

cout<<constants.GetPI( );和cout<<Constants.GetPI( );

cout<GetPI( );和cout<GetPI( );
cout<<constants.GetPI( );和cout<<Constants::GetPI( );

9 在 C++中执行以下 4 条语句后输出 rad 值为( )static int hot=200；

int &rad=hot；

hot=hot+100；

cout<<rad<<endl；

100
喵查答案：300
500

10 已知: int m=10；下列表示引用的方法中，正确的是（）
int &Z；
int &t=10；
喵查答案：int &X=m；
float &f=&m；

11 在 C++中用（）能够实现将参数值带回。
数组
指针
引用
喵查答案：上述 ABC 都可

12 有如下类的定义：Class MyClass{ int value;public: MyClass(int n):value(n){} int getValue() const {return value;}};则类Myclass的构造函数的个数是（）

1个
喵查答案：

2个
3个
4个

13 有如下头文件：int F1();static int F2();classs CA{public: int F3(); static int F4();};在所描述的函数中，具有隐含this指针的是（）

F2
喵查答案：F3
F4

14 在类定义的外部，可以被访问的成员有（）

所有类成员

private或protected的类成员
喵查答案：

public的类成员

public或private的类成员

1 类的私有成员可在何处访问（）
通过子类的对象访问
本类及子类的成员函数中
通过该类对象访问
喵查答案：本类的成员函数中

2 对类中声明的变量，下列描述中正确的是（）

属于全局变量

只属于该类
喵查答案：

属于该类，某些情况下也可被该类不同实例所共享
任何情况下都可被该类所有实例共享

3 如没有使用private关键字定义类的数据成员，则默认为（）
public
喵查答案：private
protected
friend

4 关于 new 运算符的下列描述中，错误的是（）

它可以用来动态创建对象和对象数组

使用它创建的对象或对象数组可以使用运算符 delete 删除

使用它创建对象时要调用构造函数
喵查答案：使用它创建对象数组时必须指定初始值

5 设类A将其它类对象作为成员，则建立A类对象时，下列描述正确的是（）

A类构造函数先执行
喵查答案：

成员构造函数先执行
两者并行执行
不能确定

6 如果没有为一个类定义任何构造函数的情况下，下列描述正确的是（）
喵查答案：

编译器总是自动创建一个不带参数的构造函数

这个类没有构造函数

这个类不需要构造函数
该类不能通过编译

7 下列不是构造函数特征的是（）

构造函数的函数名与类名相同

构造函数可以重载
构造函数可以设置缺省参数
喵查答案：构造函数必须指定返回类型

8 关于成员函数特征的下列描述中，错误的是（）
喵查答案：

成员函数一定是内联函数

成员函数可以重载
成员函数可以设置缺省参数值
成员函数可以是静态的

9 下列关于类的权限的描述错误的是（）
喵查答案：类本身的成员函数只能访问自身的私有成员

类的对象只能访问该类的公有成员

普通函数不能直接访问类的公有成员，必须通过对象访问
一个类可以将另一个类的对象作为成员

1 下面（）内存区域是C++中的运行时动态内存分配区域。
喵查答案：布里奇曼
代码区
钱伯斯
栈区
勒诺特尔
数据区
郎世宁
喵查答案：堆区

2 二维数组int b[][4]={{1，2}，{1，2，3}，{1，2，3，4}}的元素个数为（）。
7
宅园
9
喵查答案：文人园
10
宫苑
喵查答案：12
圣苑

3 假定AA为一个类，a为该类公有的数据成员，px为指向该类对象的一个指针，则访问px所指对象中数据成员a的格式为（）。
丰富的文化和社交活动，也使园林的类型多种多样
注重适宜的小气候环境
园林布局采用规则式样以求与建筑协调
喵查答案：园林布局采用自然形式以求对比突出建筑
px(a)
px[a]
喵查答案：px->a
px.a

4 下面说法正确的是（）。
喵查答案：构造函数可以重载，析构函数不能重载
肖蒙山丘公园是最具代表性的拿破仑三世风格的作品
构造函数不能重载，析构函数可以重载
具有令人赞叹的多变的地貌景观和空间层次
构造函数可以重载，析构函数也可以重载
喵查答案：公园中心是高大山峰，没有湖泊
构造函数和析构函数都不可以重载
在山顶仿照替沃里的西比勒庙宇建造了圆亭

5 一个类中的公有（public）性质的静态数据成员，以下（）访问方式是错误的。
望景楼花园

对象名.静态数据成员名
法尔奈斯庄园
指向对象的指针—>静态数据成员名
喵查答案：邱园
类名::静态数据成员名
波波里花园
喵查答案：类名.静态数据成员名

6 下列（）对象的数据成员类型可以不用初始化表的方式进行初始化。
喵查答案：正确
错误

常量数据成员
引用数据成员
类中对象成员
喵查答案：一般数据成员

7 类中的静态数据成员都是公有的(public)。
喵查答案：伯肯海德公园
中央公园

海德公园
肯辛顿园
正确
喵查答案：错误

8 类中所有数据成员都是在构造函数内完成。
人们追求对现世生活的悲观绝望态度
人们宣传、信仰基督教文化
强烈批判古代希腊、罗马文化来表达自己的文化主张
喵查答案：佛罗伦萨是意大利文艺复兴美术发展最主要的中心
正确
喵查答案：错误

9 不管是建立何种对象，在对象不使用时，都应该手动调用析构函数进行清除对象的操作。
陵寝园林
正确
模纹花坛
喵查答案：错误
喵查答案：空中花园
圣苑园林

10 构造函数和析构函数一般的权限都应该设为public。
斑块状小树林
下沉式道路
独立小村庄
喵查答案：规则式花坛
喵查答案：正确
错误

11 默认拷贝构造函数只能完成“浅拷贝”。
喵查答案：教会；《圣经》
喵查答案：正确
贵族；皇权
错误
民众；民主
科教；科学

12 类中的静态数据成员为了方便访问，一般还需要再类中定义静态成员函数用于访问。
勒·诺特尔
喵查答案：兰斯洛特·布朗
克洛德·莫莱
雅克·布瓦索
喵查答案：正确
错误

13 类中的非静态成员函数不能访问类的静态数据成员。
理性主义
古典主义
喵查答案：经验主义
享乐主义
正确
喵查答案：错误

14 const关键词可以参与区分重载函数。
喵查答案：正确
喵查答案：正确
错误
错误

1 若有定义：”int a[10],*p;p=a;”则执行”p=p+5;”后，与*p不相等的是（）
a[5]
正确
*(a+5)
喵查答案：错误
*(p+5)或p[5]
喵查答案：执行“a=a+5;”后的*a

2 下列关于this指针的叙述中，正确的是（）
喵查答案：正确

this指针是一个隐含指针，它隐含于类的成员函数中
错误

只有在使用this时，系统才会将对象的地址赋值给this

类的友元函数也有this指针
喵查答案：

this指针表示了成员函数当前操作的数据所属的对象

3 关于动态存储分配，下列说法正确的是（）
new 和 delete是 C++语言中专门用于动态内存分配和释放的函数
喵查答案：动态分配的内存控件也可以被初始化
当系统内存不够时，会自动回收不再使用的内存单元，因此程序中不必要使用delete释放内存控件
当动态分配内存失败时，系统回立刻崩溃，因此一定要谨慎使用 new
喵查答案：正确
错误

4 要定义整型数组x，使之包括初值为0的三个元素，下列语句中错误的是（）
正确
喵查答案：错误

int x[3]={0，0，0}；
喵查答案：

int x[]={0}；

Static int x[3]={0}；

int x[]={0，0，0)；

5 在C++中，cin是一个（）
类
正确
喵查答案：对象
喵查答案：错误
模板
函数

6 若MyClass是一个类名，且有如下语句序列 MyClass c1，*c2； MyClass *c3=new MyClass； MyClass &c4=c1；上面的语句序列所定义的类对象的个数是（）
1
喵查答案：2
3
4
正确
喵查答案：错误

7 下列不能作为类的成员的是（）
喵查答案：自身类对象
自身类对象的指针
自身类对象的引用
另一个类的对象
正确
喵查答案：错误

8 假设person是一个类，p、q 是它的不同对象，有函数f(person x&),下列过程中没有调用拷贝构造函数的是（）
喵查答案：正确
错误
喵查答案：p(10)；
person p(q)；
person p=q；
q=f(p)；

9 下列程序无错的是（）

int sum(int a,int b)

{int sum; sum=a+b;}
正确

void sum(int a,int b)

{int sum; sum=a+b;return(sum);}
喵查答案：错误
喵查答案：

#include

Max(int a,int b)

{int c;

return(c=a>=b?a:b);}

int main( )

{cout<<max(5,6);}
float fun(void){ cout<<"Hello!Everyone";float fun1( )

10 下面程序的输出结果是（）#includeusing namespace std;int fun3(int x){ static int a=12; a=x; return (a);}int main( ){ int k=4,m=5,n; n=fun3(k); n=fun3(m);cout<<n<<endl;}
喵查答案：正确
错误
12
喵查答案：5
4
9

11 下面程序的输出结果是（）#includeusing namespace std;int main( ){ int a[3][5]={ {1,3,5,7,9},{2,4,6,8,0},{5,6,7,8,9}}; int (*p)[5];p=a; for(int i=0;i<3;i++) { for(int j=0;j<5;j++) cout<<*(*p+j)<<" "; cout<<endl; p++; }}
正确
1 3 5 9 2 4 6 8 0 5 6 7 8 9
喵查答案：错误
喵查答案：

1 3 5 7 9

2 4 6 8 0

5 6 7 8 9

12 为避免指针使用上的错误，可以在定义指针时就给指针一个值，这叫指针的初始化，下列不能初始化指针的值是（）
喵查答案：正确
喵查答案：5
错误
0
NULL
地址

13 下面程序的输出结果是（）#includeusing namespace std;int main( ){ int a[3][3]={{1,2},{3,4},{5}}; int s=0; for(int i=1;i<3;i++) for(int j=0;j<=i;j++) s+=a[i][j]; cout<<s<<endl;}
喵查答案：12
14
15
13
喵查答案：正确
错误

14 关于类和对象的说法不正确的是（）
类是对象的类，对象是类的对象
喵查答案：正确
系统不为类分配内存空间，而为对象分配内存空间
错误
喵查答案：如果把人看作动物，那么细菌也是动物
类可以看作数据类型，对象也可以叫做对象的实体、实例等

15 以下关于静态成员函数的叙述不正确的是（）
喵查答案：

使用类名可以直接调用其静态成员函数

静态成员函数属于整个类

对静态成员函数的引用允许使用对象名

在静态成员函数中不能直接引用类的非静态成员
由于英美的历史渊源，美国园林发展也会受到英国园林的影响
由于城市规模迅速扩大导致城市环境质量下降，新兴的富裕阶层纷纷离开城市去郊区居住
唐宁积极呼吁在城市中兴建公共开放空间，主张所有的城市都应该建有公园
喵查答案：美国中央公园是由奥姆斯特德独立设计的

16 关于面向对象的程序设计方法，下列说法正确的是（）
喵查答案：正确
错误
喵查答案：在面向对象的程序设计中，结构化程序设计方法仍有着重要作用
“封装性”指的是将不同类型的相关数据组合在一起，作为一个整体进行处理
“多态性”指的是对象的状态会根据运行时要求自动变化
基类的私有成员在派生类的对象中不可访问，也不占内存空间

17 以下有关成员函数特征的叙述不正确的是（）
喵查答案：成员函数一定是内联函数
成员函数可以重载
成员函数可以设置缺省数值
成员函数可以是静态的
喵查答案：正确
错误

18 以下不属于类成员函数的是（）
喵查答案：正确
喵查答案：友元函数
错误
构造函数
析构函数
虚函数

19 以下叙述中不正确的是（）
公共园林；自然主义
喵查答案：

构造函数和析构函数都可以带参数
喵查答案：自然主义；公共园林

构造函数和析构函数都是成员函数
解构主义；公共园林

程序中不能直接调用构造函数，但可以调用析构函数
公共园林；解构主义

构造函数可以重载但析构函数不可以

20 以下属于析构函数特征的是（）
正确
喵查答案：在一个类中析构函数有且仅有一个
喵查答案：错误
析构函数名与类名不能相同
析构函数的定义必须在类体内
析构函数可以带或不带参数

21 若有定义：”int a[10],*p;p=a;”则执行”p=p+5;”后，与*p不相等的是（）
a[5]
正确
*(a+5)
喵查答案：错误
*(p+5)或p[5]
喵查答案：执行“a=a+5;”后的*a

22 下列关于this指针的叙述中，正确的是（）
喵查答案：正确

this指针是一个隐含指针，它隐含于类的成员函数中
错误

只有在使用this时，系统才会将对象的地址赋值给this

类的友元函数也有this指针
喵查答案：

this指针表示了成员函数当前操作的数据所属的对象

23 关于动态存储分配，下列说法正确的是（）
new 和 delete是 C++语言中专门用于动态内存分配和释放的函数
喵查答案：动态分配的内存控件也可以被初始化
当系统内存不够时，会自动回收不再使用的内存单元，因此程序中不必要使用delete释放内存控件
当动态分配内存失败时，系统回立刻崩溃，因此一定要谨慎使用 new
喵查答案：正确
错误

24 要定义整型数组x，使之包括初值为0的三个元素，下列语句中错误的是（）
正确
喵查答案：错误

int x[3]={0，0，0}；
喵查答案：

int x[]={0}；

Static int x[3]={0}；

int x[]={0，0，0)；

25 在C++中，cin是一个（）
类
正确
喵查答案：对象
喵查答案：错误
模板
函数

26 若MyClass是一个类名，且有如下语句序列 MyClass c1，*c2； MyClass *c3=new MyClass； MyClass &c4=c1；上面的语句序列所定义的类对象的个数是（）
1
喵查答案：2
3
4
正确
喵查答案：错误

27 下列不能作为类的成员的是（）
喵查答案：自身类对象
自身类对象的指针
自身类对象的引用
另一个类的对象
正确
喵查答案：错误

28 假设person是一个类，p、q 是它的不同对象，有函数f(person x&),下列过程中没有调用拷贝构造函数的是（）
喵查答案：正确
错误
喵查答案：p(10)；
person p(q)；
person p=q；
q=f(p)；

29 下列程序无错的是（）

int sum(int a,int b)

{int sum; sum=a+b;}
正确

void sum(int a,int b)

{int sum; sum=a+b;return(sum);}
喵查答案：错误
喵查答案：

#include

Max(int a,int b)

{int c;

return(c=a>=b?a:b);}

int main( )

{cout<<max(5,6);}
float fun(void){ cout<<"Hello!Everyone";float fun1( )

30 下面程序的输出结果是（）#includeusing namespace std;int fun3(int x){ static int a=12; a=x; return (a);}int main( ){ int k=4,m=5,n; n=fun3(k); n=fun3(m);cout<<n<<endl;}
喵查答案：正确
错误
12
喵查答案：5
4
9

31 下面程序的输出结果是（）#includeusing namespace std;int main( ){ int a[3][5]={ {1,3,5,7,9},{2,4,6,8,0},{5,6,7,8,9}}; int (*p)[5];p=a; for(int i=0;i<3;i++) { for(int j=0;j<5;j++) cout<<*(*p+j)<<" "; cout<<endl; p++; }}
正确
1 3 5 9 2 4 6 8 0 5 6 7 8 9
喵查答案：错误
喵查答案：

1 3 5 7 9

2 4 6 8 0

5 6 7 8 9

32 为避免指针使用上的错误，可以在定义指针时就给指针一个值，这叫指针的初始化，下列不能初始化指针的值是（）
喵查答案：正确
喵查答案：5
错误
0
NULL
地址

33 下面程序的输出结果是（）#includeusing namespace std;int main( ){ int a[3][3]={{1,2},{3,4},{5}}; int s=0; for(int i=1;i<3;i++) for(int j=0;j<=i;j++) s+=a[i][j]; cout<<s<<endl;}
喵查答案：12
14
15
13
喵查答案：正确
错误

34 关于类和对象的说法不正确的是（）
类是对象的类，对象是类的对象
喵查答案：正确
系统不为类分配内存空间，而为对象分配内存空间
错误
喵查答案：如果把人看作动物，那么细菌也是动物
类可以看作数据类型，对象也可以叫做对象的实体、实例等

35 以下关于静态成员函数的叙述不正确的是（）
喵查答案：

使用类名可以直接调用其静态成员函数

静态成员函数属于整个类

对静态成员函数的引用允许使用对象名

36 关于面向对象的程序设计方法，下列说法正确的是（）
喵查答案：正确
错误
喵查答案：在面向对象的程序设计中，结构化程序设计方法仍有着重要作用
“封装性”指的是将不同类型的相关数据组合在一起，作为一个整体进行处理
“多态性”指的是对象的状态会根据运行时要求自动变化
基类的私有成员在派生类的对象中不可访问，也不占内存空间

37 以下有关成员函数特征的叙述不正确的是（）
喵查答案：成员函数一定是内联函数
成员函数可以重载
成员函数可以设置缺省数值
成员函数可以是静态的
喵查答案：正确
错误

38 以下不属于类成员函数的是（）
喵查答案：正确
喵查答案：友元函数
错误
构造函数
析构函数
虚函数

39 以下叙述中不正确的是（）
公共园林；自然主义
喵查答案：

构造函数和析构函数都可以带参数
喵查答案：自然主义；公共园林

构造函数和析构函数都是成员函数
解构主义；公共园林

程序中不能直接调用构造函数，但可以调用析构函数
公共园林；解构主义

构造函数可以重载但析构函数不可以

40 以下属于析构函数特征的是（）
正确
喵查答案：在一个类中析构函数有且仅有一个
喵查答案：错误
析构函数名与类名不能相同
析构函数的定义必须在类体内
析构函数可以带或不带参数

41 以下叙述中不正确的是（）
喵查答案：构造函数和析构函数是特殊的成员函数,因此不允许重载
在类定义中,通常是用成员变量描述对象的属性; 用成员函数描述对象的行为
类的一个成员只能具有一种访问控制属性
通过对象只能访问类的公有成员
喵查答案：美国中央公园
展望公园
富兰克林公园
波士顿公园系统

42 以下叙述中正确的是（）
喵查答案：正确
喵查答案：

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

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

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

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

43 关于静态数据成员的说法正确的是（）
唐宁
喵查答案：奥姆斯特德
沃克斯
帕克斯顿
喵查答案：

静态数据成员是所有同类的对象共享数据，它不能具体地属于哪一个对象

静态数据成员虽然能实现同类的对象共享数据，但破坏了类的封装性

静态数据成员只在类中声明一次即可

若C为一个类，a为它的一个对象，s为类中的一个静态数据成员，则static int a.s 可以说明s为一个静态数据成员

44 关于构造函数的说法，正确的是（）
喵查答案：

构造函数的名字与类名相同，因此同类的不同对象的构造函数是相同的
喵查答案：正确

构造函数用于代替类中的一个成员函数来在创建对象时给对象赋初值（通常是成员变量），它是由人工设计的，因此可以在任何时候，任何地方来调用它
错误

构造函数的参数多少没有定制，它的返回值的类型为void

构造函数的名字与类名相同，因此一个类只有一个构造函数，即构造函数不可重载

45 拷贝构造函数具有的下列特点中，（）是错误的
喵查答案：

拷贝构造函数的名字不能用类名

如果一个类中没有定义拷贝构造函数时，系统将自动生成一个默认的

拷贝构造函数只有一个参数，并且是该类对象的引用

拷贝构造函数是一种成员函数
肖蒙山丘公园是最具代表性的拿破仑三世风格的作品
拿破仑三世希望在这里兴建一个历史性的植物环抱的公园
喵查答案：公园中心是高大山峰，没有湖泊
在山顶仿照替沃里的西比勒庙宇建造了圆亭

46 设i , j为类X中定义的int型变量名，下列X类的构造方法中不正确的是（）
喵查答案：

void X(int k ){ i=k; }

X(int k ){ i=k; }

X(int m, int n ){ i=m; j=n; }

X( ){i=0;j=0; }
公共公园计划
喵查答案：城市美化和卫生计划
美化首都计划
改造巴黎计划

47 设 A为已定义的类名，下列声明A类的对象a的语句中正确的是（）
喵查答案：static A a=new A( );
float A a;
public A a=A( );
A a=new int( );
喵查答案：正确
错误

48 类的析构函数的作用是（）
喵查答案：伯肯海德公园
喵查答案：

删除对象
海德公园

一般成员函数
肯辛顿园

类的初始化
摄政王公园

对象初始化

49 （）是析构函数的特征
喵查答案：一个类中只能定义一个析构函数
英国工业革命在19世纪30至40年代基本完成
析构函数名与类名不同
由于工人阶层住房拥挤局促，缺乏卫生设施，环境脏乱不堪，极易导致疾病传播
析构函数的定义只能在类体内
城市环境的恶化不仅威胁到资本主义的发展，而且危及到资产阶级的安全，进行社会改革的呼声日益高涨
析构函数可以有一个或多个参数
喵查答案：当时并未出现关于公共园林的相关法令法规

50 下列说法中正确的是（）
喵查答案：正确
喵查答案：类中的函数成员可以在类体中定义，也可以在类体之外定义
错误
类定义中只能说明函数成员的函数头，不能定义函数体
类中的函数成员在类体之外定义时必须要与类声明在同一文件中
在类体之外定义的函数成员不能操作该类的私有数据成员

51 以下有关构造函数的叙述不正确的是（）
喵查答案：丘陵山坡；台地园
喵查答案：在一个类中构造函数有且仅有一个
丘陵山坡；府邸园

构造函数名必须和类名一致
河滩谷地；台地园

构造函数在定义对象是自动执行
河滩谷地；府邸园
构造函数无任何函数类型

52 类的实例化是指（）
喵查答案：

创建类的对象

定义类

指明具体类

调用类的成员
斯陀园
沃勒维贡特园
寄畅园
喵查答案：斯图海德园

53 数据封装就是将一组数据和与这组数据有关操作组装在一起，形成一个实体，这实体也就是（）
是规则式园林应用于平原地区的典型样式
喵查答案：

对象
轴线被视作廊道和纽带，起到联系自然和人工的过度作用

类
喵查答案：注重私密性的场所营造，整体空间的多变性显得重要

函数体
强调均衡稳定的空间营造，避免垂直线与水平线之间造成特别大的反差

数据块

1 下列有关C++类的说法中，不正确的是（）。
喵查答案：新起之病必是表证
类是一种用户自定义的数据类型
表证有外邪的侵袭
只有类中的成员函数或类的友元函数才能存取类中的私有成员
表证的病位较表浅

在类中，如果不做特别说明，所有成员的访问权限均为私有的
表证具有起病急的特点
喵查答案：在类中，如果不做特别说明，所有成员的访问权限均为公有的
表证可发展成里证

2 有类A如下定义：‍class A{ int v; public: A ( int n) { v = n; }‍};‍下面哪条语句是编译不会出错（）。
A a2;
A a = new A();
喵查答案：A a1(3);
A * p = new A();

3 有关析构函数的说法，不正确的是（）。
正确

析构函数有且仅有一个
喵查答案：错误

析构函数无任何函数类型
喵查答案：析构函数和构造函数一样可以有形参
析构函数的功能是在系统释放对象之前做一些内存清理工作

4 假定AB为一个类，则该类的拷贝构造函数的声明语句为（）。
正确
AB&(AB x);
喵查答案：错误
AB(AB x);
AB(AB* x);
喵查答案：AB(AB&);

5 下面的函数声明中，( )是“void BC(int a, int b);”的重载函数。
int BC(int x, int y);
喵查答案：正确
喵查答案：void BC(int a, char b);
错误
float AA(int a, char b);
int BC(int a, int b=0);

6 定义p，使p指向动态空间中包含30个整数的数组，所使用的定义语句为（）。
喵查答案：int *p=new int[30];
正确
int *p=new int(30);
喵查答案：错误
int *p=new [30];
*p=new int[30];

7 若定义类A：class A { public: A(); A(int x); … };执行语句：A a(4), b[3], *p[2]；则自动调用该类构造函数的次数是（）。
正确
6
喵查答案：错误
喵查答案：4
3
1

8 假设A是一个类的名字，下面的程序片段会调用类A的调用析构函数（）次。 ‌int main() { A * p = new A[2]; A * p2 = new A; A a; delete [] p;}
正确
喵查答案：错误
1
2
喵查答案：3
4

9 假设A 是一个类的名字，下面哪段程序不会用到A的复制构造函数（）。
喵查答案：正确
A func( ) { A tmp; return tmp; }
错误
喵查答案：A a1,a2; a1 = a2;
void func( A a) { cout << "good" << endl; }
A a1; A a2(a1);

10 假设 A 是一个类的名字，下面的语句生成了（）个类A的对象。A * arr[4] = { new A(), NULL,new A() }；
喵查答案：痰食壅积
3
喵查答案：湿热内蕴
4
喵查答案：瘀血内阻
1
气化无力
喵查答案：2
喵查答案：热结肠胃

第四部分面向对象编程技术-继承与派生

1 当派生类中有和基类一样名字的成员时，一般来说( )。
将产生二义性
喵查答案：派生类的同名成员将覆盖基类的成员
是不能允许的
基类的同名成员将覆盖派生类的成员

2 C++的继承性允许派生类继承基类的( )。

部分特性，并允许增加新的特性或重定义基类的特性

部分特性，但不允许增加新的特性或重定义基类的特性
喵查答案：

所有特性，并允许增加新的特性或重定义基类的特性

所有特性，但不允许增加新的特性或重定义基类的特性

3 当保护继承时，基类的( )在派生类中成为保护成员，不能通过派生类的对象来直接访问。

任何成员
喵查答案：

公有成员和保护成员

公有成员和私有成员

私有成员

4 在派生类中能直接访问基类的( )。
喵查答案：

公有成员，保护成员

不可访问成员，私有成员

公有成员，私有成员

保护成员，私有成员

5 下面叙述错误的是( )。
喵查答案：

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

基类的protected成员在public派生类中仍然是protected的

基类的protected成员在private派生类中是private的
基类的protected成员不能被派生类的对象访问

6 下列说法错误的是( )。
公有继承的基类中的public成员在派生类中仍是public的
喵查答案：公有继承的基类中的private成员在派生类中仍是private的
私有继承的基类中的public成员在派生类中仍是private的
保护继承的基类中的public成员在派生类中仍是protected的

7 派生类的对象对它的基类成员中( )是可以访问的。
喵查答案：公有继承的公有成员
公有继承的私有成员
公有继承的保护成员
私有继承的公有成员

8 下列对继承的描述中，错误的是( )。
析构函数不能被继承
派生类也是基类的组合
派生类的成员除了它自己的成员外，还包含了它的基类的成员
喵查答案：派生类中继承的基类成员的访问权限到派生类保持不变

9 下列对派生类的描述中，错误的是( ) 。
一个派生类可以作为另一个派生类的基类
派生类至少有一个基类
派生类的缺省继承方式是private
喵查答案：派生类只继承了基类的公有成员和保护成员

10 继承机制的作用是( )。
数据封装
信息隐藏
喵查答案：定义新类
数据抽象

1 在公有继承的情况下，基类的公有或保护成员在派生类中的访问权限（）
受限制
喵查答案：正确
喵查答案：保持不变
错误
受保护
不受保护

2 在公有派生类的成员函数不能直接访问基类中继承来的某个成员，则该成员一定是基类中的（）
喵查答案：私有成员
喵查答案：巴黎城市改造仅兴建大型公园，没有建设街头小游园
公有成员
完善的配套设施是其重要特征之一
保护成员
它使园林艺术摆脱园林的局限，开始适应城市环境
保护成员或私有成员
奥姆斯特德是美国近代风景园林的创始人和国家公园建设的先驱，

3 下面叙述不正确的是（）
以风景画为蓝本
喵查答案：放射状道路
派生类一般都用公有派生
和缓起伏的地形
点景小建筑
对基类成员的访问必须是无二义性的
赋值兼容规则也适用于多重继承的组合
喵查答案：基类的公有成员在派生类中仍然是公有的

关于下列程序说法正确的是（）#include #include #include using namespace std; class A {public: A(const char *na) {strcpy(name,na);} private: char name［80］; }; class B:public A { public: B(const char *nm):A(nm){ } void show(); }; void B::show() { cout<<"name:"<<name<<endl; } void main() { B b1("B"); b1.show(); }
能正常执行
基督教势力渗透到人们生活的各个方面，对园林也产生深刻影响

不能正常执行只能将第九行private:改为public:才能正常运行
喵查答案：法国比里城堡和蒙达尔纪城堡是中世纪西欧有代表性的寺观庭园
不能正常执行只能将第九行private:改为protected：才能正常运行
为便于防守，城堡多建在山顶上，围绕着带有木栅栏的土墙以及内、外干壕沟
喵查答案：

不能正常执行 B，C两项都行
植物是中世纪乃至后世欧洲园林的最重要的元素之一，植物景观始终是欧洲园林的主体

5 以下有关继承的叙述正确的是（）
构造函数和析构函数都能被继承
宫廷庭院
派生类是基类的组合
住宅庭院
喵查答案：派生类对象除了能访问自己的成员以外，不能访问基类中的所有成员
喵查答案：猎苑园林
基类的公有成员一定能被派生类的对象访问
公共园林

6 下列不具有访问权限属性的是（）
喵查答案：阿多尼斯园
喵查答案：非类成员
冈贝里亚庄园
阿尔多布兰迪尼庄园
伊索拉贝拉庄园
类成员
数据成员
函数成员

7 继承机制的作用是（）
水镜面
信息隐藏
喵查答案：隐垣
刺绣花坛
运河
数据封装
喵查答案：定义新类
数据抽象

8 如果一个派生类只有一个直接的基类，则这样的继承关系称为（）
喵查答案：单继承
宫苑庭园和城堡庭园
多继承
宫苑庭园和修道院庭园
类延续
喵查答案：修道院庭园和城堡庭园
类族
竞技庭园和宫廷庭园

9 C++语言建立类族是通过（）
类的嵌套
原址地形主要为沼泽地
喵查答案：类的继承
规则式的中轴对称园林
虚函数
宫苑建筑坐东朝西
抽象类
喵查答案：设计者为路易十四

10 下列有关模板和继承的叙述正确的是（）
模板和继承都可以派生出一个类系
庭园轴线有时只有一条主轴，有时分主、次轴
从类系的成员看，模板类系的成员比继承类系的成员较为稳定
喵查答案：庄园内的主体建筑仅会设在庄园最高处以控制全园，显示权贵
从动态性能看，继承类系比模板类系具有更多的动态特性
常有修剪成人工形状的植物造型艺术
喵查答案：相同类模板的不同实例一般没有联系，而派生类各种类之间有兄弟父子等关系
常有石作雕塑附属于建筑

11 在私有继承的情况下，基类成员在派生类中的访问权限（）
喵查答案：受限制
圣·高尔教堂
保持不变
坎特伯雷教堂
受保护
蒙达尔纪城堡
不受保护
喵查答案：哈德良山庄

12 C++类体系中，不能被派生类继承的有（）
常成员函数
喵查答案：构造函数
虚函数
静态成员函数

13 利用继承派生关系中的重构手段获得的新系统是为了（）
仅仅延长该系统的寿命
修正原系统内的缺陷
喵查答案：允许多个不同版本的功能可以同时使用
掩盖原系统内的缺陷

14 假设ClassY:publicX，即类Y是类X的派生类，则说明一个Y类的对象时和删除Y类对象时，调用构造函数和析构函数的次序分别为（）
喵查答案：X,Y；Y,X
X,Y；X,Y
Y,X；X,Y
Y,X；Y,X

15 派生类的对象可以访问以下那种情况继承的基类成员（）
私有继承的私有成员
公有继承的私有成员
私有继承的保护成员
喵查答案：公有继承的公有成员

16 只能在自身类和子类成员函数中被访问，无法通过对象在类外访问的成员属于（）
private
喵查答案：protected
public
publish

17 在main函数中可以用p.a的形式访问派生类对象p的基类成员a，其中a是（）
私有继承的公有成员
公有继承的私有成员
公有继承的保护成员
喵查答案：公有继承的公有成员

18 对基类和派生类的关系描述中，错误的是（）
派生类是基类的具体化
喵查答案：基类继承了派生类的属性
派生类是基类定义的延续
派生类是基类的特殊化

在哪种派生方式中，派生类可以访问基类中的protected成员（）
public和private
喵查答案：public、protected和private
protected和private
仅protected

按解释中的要求在下列程序划线处填入的正确语句是（）#include class Base{ public: void fun(){cout<<"Base::fun"<<endl；} }； class Derived:public Base{ public： void fun() { ________________ //在此空格处调用基类的函数fun() cout<<"Derived::fun"<<endl； } }；
fun()；
Base.fun()；
喵查答案：Base::fun()；
Base->fun()；

21 在公有继承的情况下，基类的公有或保护成员在派生类中的访问权限（）
受限制
喵查答案：正确
喵查答案：保持不变
错误
受保护
不受保护

22 在公有派生类的成员函数不能直接访问基类中继承来的某个成员，则该成员一定是基类中的（）
喵查答案：私有成员
喵查答案：巴黎城市改造仅兴建大型公园，没有建设街头小游园
公有成员
完善的配套设施是其重要特征之一
保护成员
它使园林艺术摆脱园林的局限，开始适应城市环境
保护成员或私有成员
奥姆斯特德是美国近代风景园林的创始人和国家公园建设的先驱，

23 下面叙述不正确的是（）
以风景画为蓝本
喵查答案：放射状道路
派生类一般都用公有派生
和缓起伏的地形
点景小建筑
对基类成员的访问必须是无二义性的
赋值兼容规则也适用于多重继承的组合
喵查答案：基类的公有成员在派生类中仍然是公有的

不能正常执行 B，C两项都行
植物是中世纪乃至后世欧洲园林的最重要的元素之一，植物景观始终是欧洲园林的主体

25 以下有关继承的叙述正确的是（）
构造函数和析构函数都能被继承
宫廷庭院
派生类是基类的组合
住宅庭院
喵查答案：派生类对象除了能访问自己的成员以外，不能访问基类中的所有成员
喵查答案：猎苑园林
基类的公有成员一定能被派生类的对象访问
公共园林

26 下列不具有访问权限属性的是（）
喵查答案：阿多尼斯园
喵查答案：非类成员
冈贝里亚庄园
阿尔多布兰迪尼庄园
伊索拉贝拉庄园
类成员
数据成员
函数成员

27 继承机制的作用是（）
水镜面
信息隐藏
喵查答案：隐垣
刺绣花坛
运河
数据封装
喵查答案：定义新类
数据抽象

28 如果一个派生类只有一个直接的基类，则这样的继承关系称为（）
喵查答案：单继承
宫苑庭园和城堡庭园
多继承
宫苑庭园和修道院庭园
类延续
喵查答案：修道院庭园和城堡庭园
类族
竞技庭园和宫廷庭园

29 C++语言建立类族是通过（）
类的嵌套
原址地形主要为沼泽地
喵查答案：类的继承
规则式的中轴对称园林
虚函数
宫苑建筑坐东朝西
抽象类
喵查答案：设计者为路易十四

30 下列有关模板和继承的叙述正确的是（）
模板和继承都可以派生出一个类系
庭园轴线有时只有一条主轴，有时分主、次轴
从类系的成员看，模板类系的成员比继承类系的成员较为稳定
喵查答案：庄园内的主体建筑仅会设在庄园最高处以控制全园，显示权贵
从动态性能看，继承类系比模板类系具有更多的动态特性
常有修剪成人工形状的植物造型艺术
喵查答案：相同类模板的不同实例一般没有联系，而派生类各种类之间有兄弟父子等关系
常有石作雕塑附属于建筑

31 在私有继承的情况下，基类成员在派生类中的访问权限（）
喵查答案：受限制
圣·高尔教堂
保持不变
坎特伯雷教堂
受保护
蒙达尔纪城堡
不受保护
喵查答案：哈德良山庄

32 C++类体系中，不能被派生类继承的有（）
常成员函数
喵查答案：构造函数
虚函数
静态成员函数

33 利用继承派生关系中的重构手段获得的新系统是为了（）
仅仅延长该系统的寿命
修正原系统内的缺陷
喵查答案：允许多个不同版本的功能可以同时使用
掩盖原系统内的缺陷

34 假设ClassY:publicX，即类Y是类X的派生类，则说明一个Y类的对象时和删除Y类对象时，调用构造函数和析构函数的次序分别为（）
喵查答案：X,Y；Y,X
X,Y；X,Y
Y,X；X,Y
Y,X；Y,X

35 派生类的对象可以访问以下那种情况继承的基类成员（）
私有继承的私有成员
公有继承的私有成员
私有继承的保护成员
喵查答案：公有继承的公有成员

36 只能在自身类和子类成员函数中被访问，无法通过对象在类外访问的成员属于（）
private
喵查答案：protected
public
publish

37 在main函数中可以用p.a的形式访问派生类对象p的基类成员a，其中a是（）
私有继承的公有成员
公有继承的私有成员
公有继承的保护成员
喵查答案：公有继承的公有成员

38 对基类和派生类的关系描述中，错误的是（）
派生类是基类的具体化
喵查答案：基类继承了派生类的属性
派生类是基类定义的延续
派生类是基类的特殊化

在哪种派生方式中，派生类可以访问基类中的protected成员（）
public和private
喵查答案：public、protected和private
protected和private
仅protected

41 在公有继承的情况下，基类的成员（私有的除外）在派生类中的访问权限（）
受限制
喵查答案：保持不变
受保护
不受保护

42 在C++中，类与类之间的继承关系具有（）
自反性
对称性
喵查答案：传递性
反对称性

43 有如下程序：#include using namespace std; class Base{ private: void fun1( ) const {cout<<”fun1”;} protected: void fun2( ) const {cout<<”fun2”;} public: void fun3( ) const {cout<<”fun3”;} }; class Derived : protected Base{ public: void fun4( ) const {cout<<”fun4”;} }; int main(){ Derived obj; obj.fun1( ); //① obj.fun2( ); //② obj.fun3( ); //③ obj.fun4( ); //④ }其中没有语法错误的语句是（）
①
②
③
喵查答案：

④

44 有如下类定义：class XA{ int x; public: XA(int n) {x=n;} }; class XB: public XA{ int y; public: XB(int a,int b); };在构造函数XB的下列定义中，正确的是（）
XB::XB（int a，int b）：x(a)，y(b){ }
喵查答案：XB::XB（int a，int b）：XA(a)，y(b) { }
XB::XB（int a，int b）：x(a)，XB(b){ }
XB::XB（int a，int b）：XA(a)，XB(b){ }

45 类O定义了私有函数F1。P和Q为O的派生类，定义为class P: protected O{…}； class Q: public O{…}。（）可以访问Fl。
O的对象
P类内
喵查答案：O类内
Q类内

46 程序如下：#include using namespace std; class A { public: A( ) {cout<<”A”;} }; class B {public:B( ) {cout<<”B”;} }; class C: public A{ B b; public: C( ) {cout<<”C”;} }; int main( ) {C obj; return 0;}执行后的输出结果是（）
CBA
BAC
ACB
喵查答案：ABC

47 C++的继承性允许派生类继承基类的（）
部分特性，并允许增加新的特性或重定义基类的特性
部分特性，但不允许增加新的特性或重定义基类的特性
喵查答案：所有特性，并允许增加新的特性或重定义基类的特性
所有特性，但不允许增加新的特性或重定义基类的特性

48 在C++中类之间的继承关系具有（）
自反性
对称性
喵查答案：传递性
反对称性

下列虚基类的声明中，正确的是（）
class virtual B: public A
喵查答案： class B: virtual public A

class B: public A virtual

virtual class B: public A

50 派生类的构造函数的成员初始化列表中，不能包含（）
基类的构造函数
派生类中子对象的初始化
喵查答案：基类中子对象的初始化
派生类中一般数据成员的初始化

51 下面叙述错误的是（）
派生类可以使用private派生
对基类成员的访问必须是无二义性的
喵查答案：基类成员的访问能力在派生类中维持不变
赋值兼容规则也适用于多继承的组合

52 下列说法中错误的是（）
保护继承时基类中的public成员在派生类中仍是public的
喵查答案：公有继承时基类中的private成员在派生类中仍是private的
私有继承时基类中的public成员在派生类中是private的
保护继承时基类中的public成员在派生类中是protected的

53 下面叙述错误的是（）
基类的protected成员在派生类中仍然是protected的
喵查答案：基类的protected成员在public派生类中仍然是protected的
基类的protected成员在private派生类中是private的
基类的protected成员不能被派生类的对象访问

当一个派生类仅有protected继承一个基类时，基类中的所有公有成员成为派生类的（）
public成员
private成员
喵查答案：protected成员
友元

一个类可以同时继承多个类，称为多继承。下列关于多继承和虚基类的表述中，错误的是（）
每个派生类的构造函数都要为虚基类构造函数提供实参
多继承时有可能出现对基类成员访问的二义性问题
喵查答案：使用虚基类可以解决二义性问题并实现运行时的多态性
建立派生类对象时，虚基类的构造函数会首先被调用

56 下列关键字中，用来表示继承方式的是（）
virtual
static
喵查答案：protected
const

下列有关派生和继承的表述中，错误的是（）
若派生类没有实现基类中的一个纯虚函数，则该派生类是抽象类
在定义派生类时，可以用关键字virtual将某个基类指定为虚基类
在生成派生类对象时，派生类构造函数要调用基类的构造函数
喵查答案：派生类中定义的成员函数可以访问基类的所有成员

58 当派生类继承一个基类时，默认的继承方式为（）
public
正确
protected
喵查答案：错误
喵查答案：private
不确定

下列描述中，错误的是（）
喵查答案：正确
公有继承时基类中的公有成员在派生类中仍是公有成员
错误
公有继承时基类中的保护成员在派生类中仍是保护成员
喵查答案：保护继承时基类中的公有成员在派生类中仍是公有成员
保护继承时基类中的保护成员在派生类中仍是保护成员

60 面向对象方法中，继承是指（）
一组对象所具有的相似性质
喵查答案：正确
一个对象具有另一个对象的性质
错误
各对象之间的共同性质
喵查答案：类之间共享属性和操作的机制

下列代码段声明了3个类 class Person{}； class Student ：public Person{}； class Undergraduate ： Student{}；下列关于这些类之间关系的描述中，错误的是（）
类Person是类Undergraduate的基类
正确
喵查答案：类Undergraduate从类Student公有继承
喵查答案：错误
类Student是类Person的派生类
类Undergraduate是类Person的派生类

下列关于继承方式的描述中，错误的是（）
如果不显式地指定继承方式，缺省的继承方式是私有(private)
喵查答案：正确
采用公有继承方式时，基类中的公有成员在派生类中仍然是公有成员
错误
采用保护继承方式时，基类中的保护成员在派生类中仍然是保护成员
喵查答案：采用私有继承方式时，基类中的私有成员在派生类中仍然是私有成员

63 有如下类定义：class MyBASE{ int k; public: void set(int n) {k=n;} int get( ) const {return k;} }; class MyDERIVED: protected MyBASE{ protected; int j; public: void set(int m,int n){MyBASE::set(m);j=n;} int get( ) const{return MyBASE::get( )+j;} };则类MyDERIVED中保护成员个数是（）
喵查答案：正确
4
错误
喵查答案：3
2
1

64 在公有派生情况下，有关派生类对象和基类对象的关系，不正确的叙述是（）
喵查答案：正确
派生类的对象可以赋给基类的对象
错误
派生类的对象可以初始化基类的引用
喵查答案：派生类的对象可以直接访问基类中的成员
派生类的对象的地址可以赋给指向基类的指针

65 设置虚基类的目的是（）
简化程序
喵查答案：正确
喵查答案：消除二义性
错误
提高运行效率
减少目标代码

66 当保护继承时，基类的（）在派生类中成为保护成员，不能通过派生类的对象来直接访问。
任何成员
喵查答案：正确
喵查答案：公有成员和保护成员
错误
公有成员和私有成员
私有成员

67 下面对派生类的描述中，错误的是（）
派生类至少有一个基类
正确
一个派生类可以作为另外一个派生类的基类
喵查答案：错误
派生类的成员除了它自己的成员外，还包含了它的基类的成员
喵查答案：派生类中继承的基类成员的访问权限到派生类中保持不变

在一个派生类的成员函数中，试图调用其基类的成员函数“void f();”，但无法通过编译。这说明（）
喵查答案：正确
喵查答案：f()是基类的私有成员
错误
f()是基类的保护成员
派生类的继承方式为私有
派生类的继承方式为保护

69 关于继承和封装说法正确的是（）
封装就是完全封闭，外部只能通过实现接口互连
喵查答案：正确
继承是封装的基础
错误
喵查答案：封装是继承的基础
子类可只继承父类的部分可继承行为和属性，也可全部继承，就像儿子可继承父亲的部分性格一样

继承是C++面向对象程序设计的重要特性之一，下列继承的说法不正确的是（）
子类与子类间可共享父类的特性
正确
子类与子类间、子类与父类间存在着细微差别
喵查答案：错误
喵查答案：子类与子类间、子类与父类间存在着很大差别
子类与父类间存在着明显的层次关系

下面的继承的说法正确的是（）class math{ …};class math1:math{ …};
math类、math1类没有继承关系
math1类是math类的父类
math1类对math类继承是公有继承
喵查答案：math1类对math类的继承是私有继承

72 关于多继承二义性的描述中，错误的是（）
一个派生类的两个基类中都有某个同名成员，在派生类中对这个成员的访问可能出现二义性
解决二义性的最常用的方法是对成员名的限定法
喵查答案：基类和派生类中同时出现的同名函数，也存在二义性问题
一个派生类是从两个基类派生出来的，而这两个基类又有一个共同的基类，对该基类成员进行访问时，可能出现二义性

73 关于公有继承的有关对象的说法正确的是（）
基类成员对基类的对象都是可见的
子类成员对子类的对象是可见的，基类成员对子类的对象也都是可见的
基类成员中的公有成员对子类的对象是可见的
喵查答案：基类成员对子类是可见的

关于虚基类的说法不正确的是（）
引进虚基类的真正目的是解决二义性问题
若某个类被说明为虚类，则被重复继承的该类在派生类对象实例中只产生一个副本
在派生类的对象被创建时，要保证虚基类的构造函数被调用一次
喵查答案：因为虚基类可被多个派生类继承，因此可以有多个副本，以适应不同的子类

75 继承是C++面向对象程序设计的重要特性之一，下列继承的说法不正确的是（）
子类与子类间可共享父类的特性
子类与子类间、子类与父类间存在着细微差别
喵查答案：子类与子类间、子类与父类间存在着很大差别
子类与父类间存在着明显的层次关系

76 关于继承的目的和作用，说法不正确的是（）
继承是为了重复利用父类的可用代码，避免重复劳动
继承可以增加自己的父类不能实现的功能的代码，使子类的功能更完善，提高程序设计效率
子类可以继承父类的函数和数据，以便重复使用
喵查答案：子类可以继承父类的所用特性，以便重复使用，这才是继承的目的

77 关于类的继承不正确的是（）
引入类的继承目的就是为了代码重用，提高编程效率
子女有父母的特征是类的继承
喵查答案：子继父产业是类的继承
子类可以全部继承父类的属性和服务，也可部分继承父类的属性和服务

78 可以用 p.a 的形式访问派生类对象p的基类成员 a ，其中a是（）
私有继承的公有成员
公有继承的私有成员
公有继承的保护成员
喵查答案：公有继承的公有成员

定义派生类时，若不使用关键字显式地规定采用何种继承方式，则默认方式为（）
喵查答案：私有继承
非私有继承
保护继承
公有继承

对于通过公有继承定义的派生类,若其成员函数可以直接访问基类的某个成员，说明该基类成员的访问权限是（）
公有或私有
私有
保护或私有
喵查答案：公有或保护

81 下列关键字中，不能用来表示继承方式的是（）
private
喵查答案：static
public
protected

如果派生类以protected方式继承基类，则原基类的protected成员和public成员在派生类中的访问属性分别是（）
public和public
public和protected
protected和public
喵查答案：protected和protected

下列有关继承和派生的叙述中，正确的是（）
派生类不能访问基类的保护成员
作为虚基类的类不能被实例化
喵查答案：派生类应当向基类的构造函数传递参数
虚函数必须在派生类中重新实现

84 在公有继承的情况下，允许派生类直接访问的基类成员包括（）
公有成员
喵查答案：公有成员和保护成员
公有成员、保护成员和私有成员
保护成员

85 下列有关继承和派生的叙述中，正确的是（）
如果一个派生类私有继承其基类，则该派生类对象不能访问基类的保护成员
派生类的成员函数可以访问基类的所有成员
基类对象可以赋值给派生类对象
喵查答案：如果派生类没有实现基类的一个纯虚函数，则该派生类是一个抽象类

86 下列说法中错误的是（）
公有继承时基类中的 public 成员在派生类中仍是 public 成员
喵查答案：私有继承时基类中的 protected 成员在派生类中仍是 protected 成员
私有继承时基类中的 public 成员在派生类中是 private 成员
保护继承时基类中的 public 成员在派生类中是 protected 成员

1 在多继承的构造函数定义中，几个基类的构造函数之间的分隔符是（）。
:
;
喵查答案：,
::

2 有如下程序#includeusing namespace std;class Base{ int x;public: Base(int n=0):x(n) { cout<<n; } int getX() const { return x;}};class Derived:public Base{ int y;public: Derived(int m,int n):y(m),Base(n){ cout<<m; } Derived(int m):y(m){ cout<<m; }};int main(){ Derived d1(1),d2(2,3); return 0;} 执行该程序屏幕上将显示输出（）。
0123
1320
喵查答案：0132
1023

3 有如下类定义：class XX{ int xdata;public: XX(int n=0):xdata(n) {}};class YY:public XX{ int ydata;public: YY(int m=0,int n=0):XX(m),ydata(n){}};YY类的对象包含的数据成员的个数为（）。
1
喵查答案：2
3
4

4 有如下程序#includeusing namespace std;class Base{protected: Base() { cout<<'A'; } Base(char c) { cout<<c; }};class Derived: public Base{public: Derived(char c):Base(c+1) { cout<<c; }};int main(){ Derived d1('B'); return 0;} 执行该程序屏幕上将显示输出（）。
BA
AB
BC
喵查答案：CB

5 应在下列程序划线处填入的正确语句是（）。class Base{ public:void fun(){cout<<"Base::fun"<<endl;}};class Derived:public Base{ void fun(){_____________ //显示调用基类的函数fun( )cout<<"Derived::fun"<<endl;}};
fun( );
Base.fun( );
喵查答案：Base::fun( );
Base->fun( );

6 有如下类声明：class A{public: A(int n) { x=n; }private: int x;};class B: public A{public: B(int a, int b);private: int y;};下列给出的关于构造函数B的定义中，正确的是（）。
B::B(int a,int b): x(a), y(b) { }
喵查答案：B::B(int a,int b): A(a), y(b) { }

B::B(int a,int b): x(a), B(b) { }

B::B(int a,int b): A(a), B(b) { }

7 被非静态成员函数访问的类的数据成员（）。
喵查答案：可以是非静态数据成员或静态数据成员
不可能是类的静态数据成员
只能是类的非静态数据成员
只能是类的静态数据成员

8 创建包含有类对象成员的派生类对象时，自动调用构造函数的执行顺序依次为（）。
派生类、对象成员所属类、基类的构造函数
对象成员所属类、基类、派生类的构造函数
喵查答案：基类、对象成员所属类、派生类的构造函数
基类、派生类、对象成员所属类的构造函数

9 设class Y:public X，即类Y是类X的派生类，则创建一个Y类的对象和删除一个Y类对象时，调用构造函数和析构函数的次序分别为（）。
Y、X; Y、X
X、Y; X、Y
Y、X; X、Y
喵查答案：X、Y; Y、X

10 下列关于派生类构造函数和析构函数的说法中，错误的是（）。
派生类的构造函数会隐含调用基类的构造函数
如果基类中没有缺省构造函数，那么派生类必须定义构造函数
喵查答案：在销毁派生类对象时，先调用基类的析构函数，再调用派生类的析构函数
在建立派生类对象时，先调用基类的构造函数，再调用派生类的构造函数

11 派生类的构造函数的成员初始化列表中，不能包含（）。

基类的构造函数

派生类中子对象的初始化
喵查答案：

基类中子对象的初始化
派生类中一般数据成员的初始化

12 多继承情况下，基类构造函数的执行顺序取决于定义派生类时所指定的各基类的顺序。
喵查答案：正确
错误

13 在私有继承中，基类中所有成员对派生类的对象都是不可见的。
喵查答案：正确
错误

14 在保护继承中，对于垂直访问同于公有继承，而对于水平访问同于私有继承。
喵查答案：正确
错误

15 在公有继承中，基类中的公有成员和私有成员在派生类中都是可见的。
正确
喵查答案：错误

16 派生类是从基类派生出来的，它不能再派生新的派生类。
正确
喵查答案：错误

17 C++语言中，既允许单继承，又允许多继承。
喵查答案：正确
错误

18 构造函数可以被继承，析构函数不能被继承。
正确
喵查答案：错误

1 假定AA为一个类，a为该类私有的数据成员，GetValue()为该类公有函数成员，它返回a的值，x为该类的一个对象，则访问x对象中数据成员a的语句正确的是（）。

x.a

x.a()

x-＞GetValue()
喵查答案：

x.GetValue()

2 当一个类的某个函数被说明为 virtual 时，下面说法正确的是( )。
喵查答案：

该函数在该类的所有派生类中都是虚函数

该函数在该类的所有派生类中只有被重新说明时才是虚函数

该函数在该类的所有派生类中只有被重新说明为 virtual 时才是虚函数

该函数在该类的所有派生类中都不是虚函数

3 关于虚函数的说法不正确的是（）。

虚函数只能是成员函数

静态成员函数不能是虚函数

虚函数不能是内联函数
喵查答案：

析构函数不能是虚函数

4 类 B 是类 A 的公有派生类，类 A 和类 B 中都定义了虚函数 func(),p 是一个指向类 A 对象的指针，则 p-＞A::func() 将 ( )。
喵查答案：

调用类 A 中的函数 func()

调用类 B 中的函数 func()

根据 p 所指的对象类型而确定调用类 A 中或类 B 中的函数 func()

既调用类 A 中函数，也调用类 B 中的函数

5 已知：p是一个指向类A数据成员m的指针，A1是类A的一个对象，如果要给m赋值为5，（）是正确的。

A1.p=5

A1->p=5
喵查答案：A1.*p=5
*A1.p=5

6 函数原型void test(int a,int b=7,char=”*”),下面的函数调用中，属于不合法调用的是（）。
test(5)
test(5,8)
喵查答案：test(6,”#”)
test(0,0,”*”)

7 实现编译时的多态性要使用（）。
喵查答案：重载函数
析构函数
构造函数
虚函数

8 下面程序的运行结果为（）。#includeusing namespace std; class A{ static int n;public: A(){n=1;} A(int num){n=num;} void print(){cout<<n;}};int A::n=2;int main(){ A a,b(3); a.print(); b.print(); cout<<endl;}
喵查答案：腹胀满有时缓解
11
喵查答案：腹痛但按之痛减
13
面色萎黄或苍白
23
喵查答案：大便闭而腹柔软
喵查答案：33
脉象沉细而有力

9 在C++语言程序中，对象之间的相互通信通过（）。
喵查答案：四肢厥冷而胸腹灼热

继承实现
口干渴但渴而不欲饮
喵查答案：

调用成员函数实现
两颧红赤而浮红如妆

封装实现
喵查答案：脉象沉迟但切之有力

函数重载实现
喵查答案：面色紫暗而舌红苔黄而干

10 下面程序的运行结果是（）。#include using namespace std; class A { public: void f1() { cout << "a"; } virtual void f2() { cout << "b"; } }; class B : public A { public: void f1() { cout << "c";} virtual void f2() { cout <f1(); pa->f2(); A *fa = (A *)&b; fa->f1(); fa->f2(); }
喵查答案：既为假症便应当舍弃
喵查答案：abcadad
喵查答案：与疾病本质相反之症

abccdcd
喵查答案：不合常规认识的症状

abccdad
与疾病本质相符之症
abcadcd

11 （）解决二义性问题。
《内经》

能使用作用域分辨操作符
《伤寒论》

只能使用虚基类
喵查答案：《伤寒质难》
喵查答案：

使用作用域分辨操作符或虚基类
《中医诊断学》

上面都不能
《景岳全书》

12 对于int *pa[5];的描述，（）是正确的。
里证的病位多在内

pa是一个指向数组的指针，所指向的数组是5个int型元素
情志劳倦所伤多里证

pa是一个指向某个数组中第5个元素的指针，该元素是int型变量
里证的范围极其广泛

pa[5]表示某个数组的第5个元素的值
里证可见恶寒或发热
喵查答案：

pa是一个具有5个元素的指针数组，每个元素是一个int型指针
喵查答案：里证可以转变为表证

13 在公有派生情况下，有关派生类对象和基类对象的关系，不正确的叙述是( ) 。
病性的寒热
喵查答案：病变的吉凶
邪正的盛衰
病证的阴阳
病位的浅深

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

派生类的对象可以初始化基类的引用
喵查答案：

派生类的对象可以直接访问基类中的成员
派生类的对象的地址可以赋给指向基类的指针

14 类的构造函数是在定义该类的一个( )时被自动调用执行的。
喵查答案：舌质苍老
成员函数
疼痛喜按
数据成员
精神委靡
喵查答案：对象
五心烦热
友元函数
畏寒得衣则减

15 假定AA为一个类，int a()为该类的一个成员函数，若该成员函数在类定义体外定义，则函数头为（）。
邪气的性质
喵查答案： int AA::a()
体质的强弱
int AA:a()
喵查答案：阳气的盛衰
AA::a()
阴血的盈亏
AA::int a()
治疗是否得当

16 假定AA为一个类，a为该类公有的数据成员，px为指向该类对象的一个指针，则访问px所指对象中数据成员a的格式为（）。
px(a)
阴盛阳虚
px[a]
阳盛阴虚
喵查答案：px->a
阳盛格阴
px.a
寒极生热
喵查答案：阴盛格阳

17 对于类定义 class A{ public: virtual void func1( ){ } void func2( ){ } }; class B:public A{ public: void func1( ){cout<<〃class B func 1〃<<end1;} virtual void func2( ){cout<<〃class B func 2〃<<end1;} };下面正确的叙述是（）。

A::func2( )和B::func1( )都是虚函数

A::func2( )和B::func1( )都不是虚函数

喵查答案：

B::func1( )是虚函数，而A::func2( )不是虚函数

B::func1( )不是虚函数，而A::func2( )是虚函数

18 下面程序的运行结果是（）。#includeusing namespace std; class base{protected: int a;public: base(){cout<<"0";}};class base1:virtual base{public: base1(){cout<<"1";}};class base2:virtual base{public: base2(){cout<<"2";}};class derived:public base1,public base2{public: derived(){cout<<"3";}};int main(){ derived obj; cout<<endl;}
喵查答案：

0123

3120

0312

3012

19 虚函数是用virtual 关键字说明的成员函数。
喵查答案：正确
错误

20 C++的虚函数必须是类的一个成员，而不允许是类的友元。
喵查答案：正确
错误

21 假定AA为一个类，a为该类私有的数据成员，GetValue()为该类公有函数成员，它返回a的值，x为该类的一个对象，则访问x对象中数据成员a的语句正确的是（）。

x.a

x.a()

x-＞GetValue()
喵查答案：

x.GetValue()

22 当一个类的某个函数被说明为 virtual 时，下面说法正确的是( )。
喵查答案：

该函数在该类的所有派生类中都是虚函数

该函数在该类的所有派生类中只有被重新说明时才是虚函数

该函数在该类的所有派生类中只有被重新说明为 virtual 时才是虚函数

该函数在该类的所有派生类中都不是虚函数

23 关于虚函数的说法不正确的是（）。

虚函数只能是成员函数

静态成员函数不能是虚函数

虚函数不能是内联函数
喵查答案：

析构函数不能是虚函数

24 类 B 是类 A 的公有派生类，类 A 和类 B 中都定义了虚函数 func(),p 是一个指向类 A 对象的指针，则 p-＞A::func() 将 ( )。
喵查答案：

调用类 A 中的函数 func()

调用类 B 中的函数 func()

根据 p 所指的对象类型而确定调用类 A 中或类 B 中的函数 func()

既调用类 A 中函数，也调用类 B 中的函数

25 已知：p是一个指向类A数据成员m的指针，A1是类A的一个对象，如果要给m赋值为5，（）是正确的。

A1.p=5

A1->p=5
喵查答案：A1.*p=5
*A1.p=5

26 函数原型void test(int a,int b=7,char=”*”),下面的函数调用中，属于不合法调用的是（）。
test(5)
test(5,8)
喵查答案：test(6,”#”)
test(0,0,”*”)

27 实现编译时的多态性要使用（）。
喵查答案：重载函数
析构函数
构造函数
虚函数

28 下面程序的运行结果为（）。#includeusing namespace std; class A{ static int n;public: A(){n=1;} A(int num){n=num;} void print(){cout<<n;}};int A::n=2;int main(){ A a,b(3); a.print(); b.print(); cout<<endl;}
喵查答案：腹胀满有时缓解
11
喵查答案：腹痛但按之痛减
13
面色萎黄或苍白
23
喵查答案：大便闭而腹柔软
喵查答案：33
脉象沉细而有力

29 在C++语言程序中，对象之间的相互通信通过（）。
喵查答案：四肢厥冷而胸腹灼热

继承实现
口干渴但渴而不欲饮
喵查答案：

调用成员函数实现
两颧红赤而浮红如妆

封装实现
喵查答案：脉象沉迟但切之有力

函数重载实现
喵查答案：面色紫暗而舌红苔黄而干

30 下面程序的运行结果是（）。#include using namespace std; class A { public: void f1() { cout << "a"; } virtual void f2() { cout << "b"; } }; class B : public A { public: void f1() { cout << "c";} virtual void f2() { cout <f1(); pa->f2(); A *fa = (A *)&b; fa->f1(); fa->f2(); }
喵查答案：既为假症便应当舍弃
喵查答案：abcadad
喵查答案：与疾病本质相反之症

abccdcd
喵查答案：不合常规认识的症状

abccdad
与疾病本质相符之症
abcadcd

31 （）解决二义性问题。
《内经》

能使用作用域分辨操作符
《伤寒论》

只能使用虚基类
喵查答案：《伤寒质难》
喵查答案：

使用作用域分辨操作符或虚基类
《中医诊断学》

上面都不能
《景岳全书》

32 对于int *pa[5];的描述，（）是正确的。
里证的病位多在内

pa是一个指向数组的指针，所指向的数组是5个int型元素
情志劳倦所伤多里证

pa是一个指向某个数组中第5个元素的指针，该元素是int型变量
里证的范围极其广泛

pa[5]表示某个数组的第5个元素的值
里证可见恶寒或发热
喵查答案：

pa是一个具有5个元素的指针数组，每个元素是一个int型指针
喵查答案：里证可以转变为表证

33 在公有派生情况下，有关派生类对象和基类对象的关系，不正确的叙述是( ) 。
病性的寒热
喵查答案：病变的吉凶
邪正的盛衰
病证的阴阳
病位的浅深

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

派生类的对象可以初始化基类的引用
喵查答案：

派生类的对象可以直接访问基类中的成员
派生类的对象的地址可以赋给指向基类的指针

34 类的构造函数是在定义该类的一个( )时被自动调用执行的。
喵查答案：舌质苍老
成员函数
疼痛喜按
数据成员
精神委靡
喵查答案：对象
五心烦热
友元函数
畏寒得衣则减

35 假定AA为一个类，int a()为该类的一个成员函数，若该成员函数在类定义体外定义，则函数头为（）。
邪气的性质
喵查答案： int AA::a()
体质的强弱
int AA:a()
喵查答案：阳气的盛衰
AA::a()
阴血的盈亏
AA::int a()
治疗是否得当

36 假定AA为一个类，a为该类公有的数据成员，px为指向该类对象的一个指针，则访问px所指对象中数据成员a的格式为（）。
px(a)
阴盛阳虚
px[a]
阳盛阴虚
喵查答案：px->a
阳盛格阴
px.a
寒极生热
喵查答案：阴盛格阳

37 对于类定义 class A{ public: virtual void func1( ){ } void func2( ){ } }; class B:public A{ public: void func1( ){cout<<〃class B func 1〃<<end1;} virtual void func2( ){cout<<〃class B func 2〃<<end1;} };下面正确的叙述是（）。

A::func2( )和B::func1( )都是虚函数

A::func2( )和B::func1( )都不是虚函数

喵查答案：

B::func1( )是虚函数，而A::func2( )不是虚函数

B::func1( )不是虚函数，而A::func2( )是虚函数

38 下面程序的运行结果是（）。#includeusing namespace std; class base{protected: int a;public: base(){cout<<"0";}};class base1:virtual base{public: base1(){cout<<"1";}};class base2:virtual base{public: base2(){cout<<"2";}};class derived:public base1,public base2{public: derived(){cout<<"3";}};int main(){ derived obj; cout<<endl;}
喵查答案：

0123

3120

0312

3012

39 虚函数是用virtual 关键字说明的成员函数。
喵查答案：正确
错误

40 C++的虚函数必须是类的一个成员，而不允许是类的友元。
喵查答案：正确
错误

如果函数f()要操作类A和类B的私有成员，可以把f()声明为类A的成员函数，把类A声明为类B的友元类。
喵查答案：正确
错误

友元函数的定义只能放在类的外部，与类的成员函数放在一起。
正确
喵查答案：错误

友元只能访问类中的公有成员，不能访问私有成员。
正确
喵查答案：错误

this是一个隐含于每一个类的成员函数的特殊指针，它是一个指向正在被某个成员函数操作的对象的指针。
喵查答案：正确
错误

建立类的对象时，先调用各个对象成员的构造函数，初始化相应的对象成员，然后才执行类的构造函数，初始化类中其他成员。
喵查答案：正确
错误

46 所谓私有成员是指只有类中所提供的成员函数才能直接使用它们，任何类以外的函数对它们的访问都是非法的。
正确
喵查答案：错误

47 假定AA为一个类，a为该类公有的数据成员，x为该类的一个对象，则访问x对象中数据成员a的格式为x-＞a。
正确
喵查答案：错误

第五部分面向对象编程技术-多态性

1 有以下类定义：class A{public: virtual void f1(){ cout<<1; }; void f2(){ cout<<2; };};class B : public A{public: void f1(){ cout<<3;} void f2(){ cout<<4;}};若b为B类对象，p为A类指针，则下列选项正确的是（）。
喵查答案：执行：p=&b; p->f1();语句，输出3
执行：p=&b; p->f2();语句，输出4
执行：p=&b; p->f1();语句，输出2
执行：p=&b; p->f2();语句，输出1

2 类定义如下。class A{public:virtual void func1( ){ }void fun2( ){ }};class B:public A{public:void func1( ) {cout<<”class B func1”<<endl;}virtual void func2( ) {cout<<”class B func2”<<endl;}};则下面正确的叙述是（）。
喵查答案：A::func2( )和B::func1( )都是虚函数
A::func2( )和B::func1( )都不是虚函数
B::func1( )是虚函数，而A::func2( )不是虚函数
B::func1( )不是虚函数，而A::func2( )是虚函数

3 （）是一个在基类中说明的虚函数，它在该基类中没有定义，但要求任何派生类都必须定义自己的版本。
虚析构函数
虚构造函数
喵查答案：纯虚函数
静态成员函数

4 一个类可以同时继承多个类，称为多继承。下列关于多继承和虚基类的表述中，错误的是（）。
每个派生类的构造函数都要为虚基类构造函数提供实参
多继承时有可能出现对基类成员访问的二义性问题
喵查答案：使用虚基类可以解决二义性问题并实现运行时的多态性
建立派生类对象时，虚基类的构造函数会首先被调用

5 下列选项中，与实现运行时多态性无关的是（）。
喵查答案：重载函数
虚函数
指针
引用

6 下列有关运算符重载的叙述中，正确的是（）。
喵查答案：运算符重载是多态性的一种表现
C++中可以通过运算符重载创造新的运算符
C++中所有运算符都可以作为非成员函数重载
重载运算符时可以改变其结合性

7 结构化程序设计的基本原则不包括（）。
喵查答案：多态性
自顶向下
模块化
逐步求精

8 虚函数支持多态调用，一个基类的指针可以指向派生类的对象，而且通过这样的指针调用虚函数时，被调用的是指针所指的实际对象的虚函数。而非虚函数不支持多态调用。有如下程序：#includeusing namespace std;class Base{public: virtual void f(){cout<<"f0+";} void g(){cout<<"g0+";}};class Derived:public Base{public: void f(){cout<<"f+";} void g(){cout<<"g+";}};int main(){ Derived d; Base *p=&d; p->f();p->g(); return 0;}运行时输出的结果是（）。
f+g+
f0+g+
喵查答案：f+g0+
f0+g0+

9 如果不使用多态机制，那么通过基类的指针虽然可以指向派生类对象，但是只能访问从基类继承的成员。有如下程序，没有使用多态机制。#includeusing namespace std;class Base{ int a,b;public: Base(int x,int y) {a=x;b=y;} void show(){cout<<a<<','<<b<<endl;}};class Derived:public Base{ int c,d;public: Derived(int x,int y,int z,int m):Base(x,y){c=z;d=m;} void show(){cout<<c<<','<<d<<endl;}};int main(){ Base B1(50,50),*pb; Derived D1(10,20,30,40); pb=&D1; pb->show(); return 0;}运行时输出的结果是( )。
喵查答案：10,20
30,40
20,30
50,50

10 在C++中,要实现动态联编,必须使用（）调用虚函数。
类名
派生类指针
对象名
喵查答案：基类指针

11 多态调用是指（）。
以任何方式调用一个虚函数
以任何方式调用一个纯虚函数
喵查答案：借助于指向对象的基类指针或引用调用一个虚函数
借助于指向对象的基类指针或引用调用一个纯虚函数

12 下列函数中,不能说明为虚函数的是（）。
私有成员函数
公有成员函数
喵查答案：构造函数
析构函数

13 有如下的程序#includeusing namespace std; class B{ public: virtual void show(){ cout<<"B";}}; class D:public B{ public: void show(){ cout<<"D";}}; void fun1(B *ptr) { ptr->show(); }void fun2(B &ref) { ref.show(); }void fun3(B b) { b.show(); } int main(){ B b,*p=new D; D d; fun1(p); fun2(b); fun3(d); return 0;}程序的运行结果是（）。
DBD
BBD
喵查答案：DBB
DBD

14 下列描述中，（）是抽象类的特征。
可以说明虚函数
可以进行构造函数重载
可以定义友元函数
喵查答案：不能建立其对象

15 下面选项中，（）是用来声明虚函数的。
喵查答案：virtual
public
using
False

16 关于虚函数的描述中，（）是正确的。
虚函数是一个静态成员函数
虚函数是一个非成员函数
虚函数没有this指针
喵查答案：派生类的虚函数与基类中对应的虚函数具有相同的参数个数和类型

17 有如下的程序#includeusing namespace std;class Base{public: void fun1(){cout<<"Base\n"; } virtual void fun2(){ cout<<"Base\n";}};class Derived: public Base{public: void fun1() { cout<<"Derived\n"; } void fun2() {cout<<"Derived\n"; }};void f(Base &b) { b.fun1();b.fun2(); }int main(){ Derived obj; f(obj); return 0;}程序的运行结果是（）。
Base Base
喵查答案：BaseDerived
DerivedBase
DerivedDerived

18 下面是类Shape的定义class Shape{ public: virtual void Draw()=0;};下列关于Shape类的描述中，正确的是（）。
类Shape是虚基类
喵查答案：类Shape是抽象类
类Shape中的Draw函数声明有误
语句“Shape s”能够建立Shape的一个对象

19 在面向对象的方法中，实现信息隐蔽是依靠（）。
对象的继承
对象的多态
喵查答案：对象的封装
对象的分类

20 如果采用动态多态性，要调用虚函数的是（）。
喵查答案：基类对象指针
对象名
基类对象
派生类名

21 有以下类定义：class A{public: virtual void f1(){ cout<<1; }; void f2(){ cout<<2; };};class B : public A{public: void f1(){ cout<<3;} void f2(){ cout<<4;}};若b为B类对象，p为A类指针，则下列选项正确的是（）。
喵查答案：执行：p=&b; p->f1();语句，输出3
执行：p=&b; p->f2();语句，输出4
执行：p=&b; p->f1();语句，输出2
执行：p=&b; p->f2();语句，输出1

22 类定义如下。class A{public:virtual void func1( ){ }void fun2( ){ }};class B:public A{public:void func1( ) {cout<<”class B func1”<<endl;}virtual void func2( ) {cout<<”class B func2”<<endl;}};则下面正确的叙述是（）。
喵查答案：A::func2( )和B::func1( )都是虚函数
A::func2( )和B::func1( )都不是虚函数
B::func1( )是虚函数，而A::func2( )不是虚函数
B::func1( )不是虚函数，而A::func2( )是虚函数

23 （）是一个在基类中说明的虚函数，它在该基类中没有定义，但要求任何派生类都必须定义自己的版本。
虚析构函数
虚构造函数
喵查答案：纯虚函数
静态成员函数

24 一个类可以同时继承多个类，称为多继承。下列关于多继承和虚基类的表述中，错误的是（）。
每个派生类的构造函数都要为虚基类构造函数提供实参
多继承时有可能出现对基类成员访问的二义性问题
喵查答案：使用虚基类可以解决二义性问题并实现运行时的多态性
建立派生类对象时，虚基类的构造函数会首先被调用

25 下列选项中，与实现运行时多态性无关的是（）。
喵查答案：重载函数
虚函数
指针
引用

26 下列有关运算符重载的叙述中，正确的是（）。
喵查答案：运算符重载是多态性的一种表现
C++中可以通过运算符重载创造新的运算符
C++中所有运算符都可以作为非成员函数重载
重载运算符时可以改变其结合性

27 结构化程序设计的基本原则不包括（）。
喵查答案：多态性
自顶向下
模块化
逐步求精

28 虚函数支持多态调用，一个基类的指针可以指向派生类的对象，而且通过这样的指针调用虚函数时，被调用的是指针所指的实际对象的虚函数。而非虚函数不支持多态调用。有如下程序：#includeusing namespace std;class Base{public: virtual void f(){cout<<"f0+";} void g(){cout<<"g0+";}};class Derived:public Base{public: void f(){cout<<"f+";} void g(){cout<<"g+";}};int main(){ Derived d; Base *p=&d; p->f();p->g(); return 0;}运行时输出的结果是（）。
f+g+
f0+g+
喵查答案：f+g0+
f0+g0+

29 如果不使用多态机制，那么通过基类的指针虽然可以指向派生类对象，但是只能访问从基类继承的成员。有如下程序，没有使用多态机制。#includeusing namespace std;class Base{ int a,b;public: Base(int x,int y) {a=x;b=y;} void show(){cout<<a<<','<<b<<endl;}};class Derived:public Base{ int c,d;public: Derived(int x,int y,int z,int m):Base(x,y){c=z;d=m;} void show(){cout<<c<<','<<d<<endl;}};int main(){ Base B1(50,50),*pb; Derived D1(10,20,30,40); pb=&D1; pb->show(); return 0;}运行时输出的结果是( )。
喵查答案：10,20
30,40
20,30
50,50

30 在C++中,要实现动态联编,必须使用（）调用虚函数。
类名
派生类指针
对象名
喵查答案：基类指针

31 多态调用是指（）。
以任何方式调用一个虚函数
以任何方式调用一个纯虚函数
喵查答案：借助于指向对象的基类指针或引用调用一个虚函数
借助于指向对象的基类指针或引用调用一个纯虚函数

32 下列函数中,不能说明为虚函数的是（）。
私有成员函数
公有成员函数
喵查答案：构造函数
析构函数

33 有如下的程序#includeusing namespace std; class B{ public: virtual void show(){ cout<<"B";}}; class D:public B{ public: void show(){ cout<<"D";}}; void fun1(B *ptr) { ptr->show(); }void fun2(B &ref) { ref.show(); }void fun3(B b) { b.show(); } int main(){ B b,*p=new D; D d; fun1(p); fun2(b); fun3(d); return 0;}程序的运行结果是（）。
DBD
BBD
喵查答案：DBB
DBD

34 下列描述中，（）是抽象类的特征。
可以说明虚函数
可以进行构造函数重载
可以定义友元函数
喵查答案：不能建立其对象

35 下面选项中，（）是用来声明虚函数的。
喵查答案：virtual
public
using
False

36 关于虚函数的描述中，（）是正确的。
虚函数是一个静态成员函数
虚函数是一个非成员函数
虚函数没有this指针
喵查答案：派生类的虚函数与基类中对应的虚函数具有相同的参数个数和类型

37 有如下的程序#includeusing namespace std;class Base{public: void fun1(){cout<<"Base\n"; } virtual void fun2(){ cout<<"Base\n";}};class Derived: public Base{public: void fun1() { cout<<"Derived\n"; } void fun2() {cout<<"Derived\n"; }};void f(Base &b) { b.fun1();b.fun2(); }int main(){ Derived obj; f(obj); return 0;}程序的运行结果是（）。
Base Base
喵查答案：BaseDerived
DerivedBase
DerivedDerived

38 下面是类Shape的定义class Shape{ public: virtual void Draw()=0;};下列关于Shape类的描述中，正确的是（）。
类Shape是虚基类
喵查答案：类Shape是抽象类
类Shape中的Draw函数声明有误
语句“Shape s”能够建立Shape的一个对象

39 在面向对象的方法中，实现信息隐蔽是依靠（）。
对象的继承
对象的多态
喵查答案：对象的封装
对象的分类

40 如果采用动态多态性，要调用虚函数的是（）。
喵查答案：基类对象指针
对象名
基类对象
派生类名

41 在派生类中定义虚函数时，可以与基类中相应的虚函数不同的是（）。
参数类型
参数个数
函数名称
喵查答案：函数体

42 要实现动态联编必须（）。
通过成员名限定来调用虚函数
通过对象名来调用虚函数
通过派生类对象来调用虚函数
喵查答案：通过对象指针或引用来调用虚函数

43 如果表达式++a中的“++”是作为成员函数重载的运算符，若采用运算符函数调用格式，则可表示为（）。
a.operator++(1)
operator++(a)
operator++(a,1)
喵查答案：a.operator++( )

44 下列运算符中，在C++语言中不能重载的是（）。
*
>=
喵查答案：：：
/

45 当一个类的某个函数被说明为virtual时，该函数在该类的所有派生类中（）。
喵查答案：都是虚函数
只有被重新说明时才是虚函数
只有被重新说明为virtual时才是虚函数
都不是虚函数

46 编译时的多态性通过函数（）实现。
喵查答案：重载
继承
调用
抽象

47 抽象类中至少要有一个（）函数。
喵查答案：纯虚
重载
析构
友元

48 在C++中用来实现运行时多态性的是（）。
重载函数
析构函数
构造函数
喵查答案：虚函数

49 下面有关重载函数的说法中正确的是（）。
重载函数必须具有不同的返回值类型
重载函数形参个数必须不同
喵查答案：重载函数必须有不同的形参列表
重载函数名可以不同

50 在下面的运算符重载函数的原型中，错误的是（）。
喵查答案：Volume operator – (double, double);
double Volume::operator- (double);
Volume Volume: :operator – (Volume);
Volume operator – (Volume, Volume);

51 在C++中用来实现运行时多态性的是（）。
重载函数
析构函数
构造函数
喵查答案：虚函数

52 下列叙述中，正确的是（）。
虚函数必须在派生类中定义，基类不需定义
喵查答案：一个基类定义的虚函数，该类的所有派生类都继承并拥有该函数
派生类中重定义虚函数时，参数表必须改变
虚函数的返回类型必须是void

53 关于纯虚函数和抽象类的描述中，错误的是（）。
纯虚函数是一种特殊的虚函数，它没有具体的实现
抽象类是指具有纯虚函数的类
喵查答案：一个基类说明中有纯虚函数，该基类的派生类不再是抽象类
抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出

54 类B是类A的公有派生类，类A和类B中都定义了虚函数func( ),p是一个指向类A对象的指针，则p->A::func( )将（）。
喵查答案：调用类A中的函数func()
调用类B中的函数func()
根据p所指的对象类型而确定调用类A中或类B中的函数func()
既调用类A中函数，也调用类B中的函数

55 #include using namespace std; class A { int i; public: virtual void fun()=0; A(int a) {i=a;} }; class B:public A { int j; public: void fun() {cout<fun(); }

程序第17行，下列（）选项，不能使得屏幕输出 B::fun()＼n
喵查答案：B(int m,int n=0):j(n){}
B(int m,int n=0):A(m) {}
B(int m,int n=0):j(n),A(m){}
B(int m,int n=0):A(m),j(n){}

56 不同对象可以调用相同名称的函数，但执行完全不同行为的现象称为（）。
继承
喵查答案：多态
封装
抽象

57 以下基类中的成员函数表示纯虚函数的是（）。
喵查答案：virtual void tt()=0
void tt(int)=0
virtual void tt(int)
virtual void tt(int){}

58 有关多态性说法不正确的是（）。
C++语言的多态性分为编译时的多态性和运行时的多态性
编译时的多态性可通过函数重载实现
喵查答案：运行时的多态性可通过模板和虚函数实现
实现运行时多态性的机制称为动态多态性

59 所谓多态性是指（）。
不同的对象调用不同名称的函数
喵查答案：不同的对象调用相同名称的函数
一个对象调用不同名称的函数
一个对象调用不同名称的对象

下列是模板声明的开始部分，其中正确的是( )。

template

template
喵查答案：

template

下面是类Shape的定义：

class Shape {

public：

virtual void Draw()=0;

};

下列关于Shape类的描述中，正确的是( )。

类Shape是虚基类
喵查答案：

类Shape是抽象类

类Shape中的Draw函数声明有误

语句“Shape s；”能够建立Shape的一个对象s

有如下程序：

#include

using namespace std;

class XX{

protected:

int k;

public:

XX(int n=5):k(n){}

~XX(){cout<<"XX";}

virtual void f()const=0;

};

inline void XX::f()const{cout<<k+3;}

class YY:public XX{

public:

~YY(){cout<<"YY";}

void f()const{cout<<k-3;XX::f();}

};

int main(){

XX &p=*new YY;

p.f();

delete &p;

return 0;

};

执行上面的程序将输出( )。
喵查答案：

28XX

28YYXX

-33XX

-33XXYY

下列程序中划线处正确的语句是（）。

#include

using namespace std;

class Base

{

public:

void fun(){ cout<<”Base::fun”<<endl;}

};

class Derived : public Base

{

void fun()

{ _____________________

cout<<”Derived::fun”<<endl; //显式调用基类的函数 fun()

}

};
fun();

Base.fun();
喵查答案：

Base::fun();

Base->fun();

下面程序的输出结果是( )。

#include

using namespace std;

unsigned func(unsigned num)

{ unsigned d=1,k;

do{

k=num % 10;

num/=10;

}while(num);

return (k);}

int main( )

{ unsigned n=26;

cout<<func(n);}
喵查答案：2
3
6
5

下面程序当输入3.5，4.5，+，时，输出的结果是( )。

#include

using namespace std;

float result(float x,float y,char ch)

{ float result1;

switch(ch)

{ case ‘+’: result1=x+y;return(result1);

case ‘-‘: result1=x-y;return(result1);break;

case ‘*’: result1=x*y;return(result1);

case ‘/’: result1=x/y;return(result1);break;

}

int main( )

{ char ch; float x,y;

cout<<"请输入一个运算符";

cin>>ch;

cout<<endl;

cout<<"请输入两个运算数：";

cin>>x;cout<<endl;

cin>>y;cout<<endl;

cout<<"运算结果是："<<result (x,y,ch);

}
喵查答案：8
8,-1
15.8
15.8 0.78

在下面的类定义中，错误的语句是( )。

Class Sample

{

public:

Sample(int val);

～Sample();

private:

int a=2.5;

Sample();

};
Sample(int val);

～Sample();
喵查答案：

int a=2.5;

Sample();

下面程序的输出结果是( )。

#include

using namespace std;

int main()

{

char name[2][6];

strcpy(name[0], “zhang”);

strcpy(name[1], “san”);

cout<<name[0]<<" "<<name[1];

return 0;

}
喵查答案：zhang san
zhang

san
出错

下列关于字符串的输入正确的是( )。
喵查答案：

char ch[10];cin>>&ch[2];

scanf(“%c”,ch[1]);

scanf(“%s”,&ch);

cin>>ch;

下面程序的输出结果是( )。

#include

using namespace std;

int main()

{

int x[6]={1,3,5,7,9,11},*k,**s;

k=x;

s=&k;

cout<<*(k++)<<","<<**s<<endl;

return 0;

}

3,3
喵查答案：

1,1

3,5

1,3

要定义整型数组x，使之包括初值为0的三个元素，下列语句中错误的是（）。

int x[3]={0，0，0}；
喵查答案：

int x[]={0}；

Static int x[3]={0)；

int x[]={0，0，0)；

下列关于运算符重载的描述中，正确的是（）。
喵查答案：

运算符重载为成员函数时，若参数表中无参数，重载的是一元运算符

一元运算符只能作为成员函数重载

二元运算符重载为非成员函数时，参数表中有一个参数

C++中可以重载所有的运算符

已知类X成功地重载了――、＝、＋、和[ ]这几个运算符，则其中肯定属于成员函数的运算符是( )。
＋和＝
[ ]和后置――
喵查答案：＝和[ ]
前置――和[ ]

对于常成员函数，下面描述正确的是( )。

常成员函数只能修改常数据成员

常成员函数只能修改一般数据成员
喵查答案：

常成员函数不能修改任何数据成员

常成员函数只能通过常对象调用

语句ofstream f(“DATA.DAT”,ios_base::app|ios_base::binary);的功能是建立流对象f,并试图打开文件DATA.DAT并与之连接，而且( )。

若文件存在，将文件指针定位于文件首；若文件不存在，建立一个新文件

若文件存在，将其截为空文件；若文件不存在，打开失败
喵查答案：

若文件存在，将文件指针定位于文件尾；若文件不存在，建立一个新文件

若文件存在，打开失败；若文件不存在，建立一个新文件

下面程序的输出结果是( )。

#include

using std::cout; using std::endl;

template

T max(T x,T y)

{return(x>=y)?x:y;}

template

T max(T x,T y,T z)

{T t; t=(x>=y)?x:y;

return (t>=z)?t:z;}

int main( )

{ int x=10,y=18,max1;

float a=1.2,b=3.2,c=2,max2;

max1=max(x,(int)c);

max2=max(a,b,(float)y);

cout<<max1<<endl;

cout<<max2<<endl; }

3.2
喵查答案：

3.2

编译出错

关于成员函数的重载，说法正确的是( )。

就是在类中设计多个函数名相同，参数个数及参数类型也相同的函数

析构函数可以重载
喵查答案：

函数重载，要求函数名相同，但参数个数不同，或参数相同，但其类型不同

构造函数不可重载

下面关于转换函数重载的说法正确的是( )。

转换函数的重载与普通函数的重载是一样的，也是靠函数的参数的个数和类型来区别不同的函数

转换函数没有参数，因此不能重载，否则将发生二义性
喵查答案：

转换函数虽然没有参数，但可以依靠函数的类型区别，所以可以重载

对转换函数进行调用时，必须使用强制类型转换以指明调用的是哪个转换函数

有以下程序

#include

using namespace std;

class MyClass

{

public:

MyClass(int n) {number=n;}

//拷贝构造函数

MyClass(MyClass&other){number=other.number;}

~MyClass(){}

private:

int number;

};

MyClass fun(MyClass p)

{

MyClass temp(p);

return temp;

}

int main()

{

MyClass obj1(10),obj2(0);

MyClass obj3(obj1);

obj2=fun(obj3);

return 0;

}

程序执行时，MyClass类的拷贝构造函数被调用的次数是（）。
5
喵查答案：4
3
3

有以下类定义

class MyClass

{

public:

MyClass() { cout<<1;}

};

int main()

{

MyClass a;

MyClass b[2];

MyClass *p[2];

}

执行语句 MyClass a,b[2],*p[2]；后，程序的输出结果是（）。
11
喵查答案：111
1111
11111

下列是模板声明的开始部分，其中正确的是( )。

template

template
喵查答案：

template

下面是类Shape的定义：

class Shape {

public：

virtual void Draw()=0;

};

下列关于Shape类的描述中，正确的是( )。

类Shape是虚基类
喵查答案：

类Shape是抽象类

类Shape中的Draw函数声明有误

语句“Shape s；”能够建立Shape的一个对象s

有如下程序：

#include

using namespace std;

class XX{

protected:

int k;

public:

XX(int n=5):k(n){}

~XX(){cout<<"XX";}

virtual void f()const=0;

};

inline void XX::f()const{cout<<k+3;}

class YY:public XX{

public:

~YY(){cout<<"YY";}

void f()const{cout<<k-3;XX::f();}

};

int main(){

XX &p=*new YY;

p.f();

delete &p;

return 0;

};

执行上面的程序将输出( )。
喵查答案：

28XX

28YYXX

-33XX

-33XXYY

下列程序中划线处正确的语句是（）。

#include

using namespace std;

class Base

{

public:

void fun(){ cout<<”Base::fun”<<endl;}

};

class Derived : public Base

{

void fun()

{ _____________________

cout<<”Derived::fun”<<endl; //显式调用基类的函数 fun()

}

};
fun();

Base.fun();
喵查答案：

Base::fun();

Base->fun();

下面程序的输出结果是( )。

#include

using namespace std;

unsigned func(unsigned num)

{ unsigned d=1,k;

do{

k=num % 10;

num/=10;

}while(num);

return (k);}

int main( )

{ unsigned n=26;

cout<<func(n);}
喵查答案：2
3
6
5

下面程序当输入3.5，4.5，+，时，输出的结果是( )。

#include

using namespace std;

float result(float x,float y,char ch)

{ float result1;

switch(ch)

{ case ‘+’: result1=x+y;return(result1);

case ‘-‘: result1=x-y;return(result1);break;

case ‘*’: result1=x*y;return(result1);

case ‘/’: result1=x/y;return(result1);break;

}

int main( )

{ char ch; float x,y;

cout<<"请输入一个运算符";

cin>>ch;

cout<<endl;

cout<<"请输入两个运算数：";

cin>>x;cout<<endl;

cin>>y;cout<<endl;

cout<<"运算结果是："<<result (x,y,ch);

}
喵查答案：8
8,-1
15.8
15.8 0.78

在下面的类定义中，错误的语句是( )。

Class Sample

{

public:

Sample(int val);

～Sample();

private:

int a=2.5;

Sample();

};
Sample(int val);

～Sample();
喵查答案：

int a=2.5;

Sample();

下面程序的输出结果是( )。

#include

using namespace std;

int main()

{

char name[2][6];

strcpy(name[0], “zhang”);

strcpy(name[1], “san”);

cout<<name[0]<<" "<<name[1];

return 0;

}
喵查答案：zhang san
zhang

san
出错

下列关于字符串的输入正确的是( )。
喵查答案：

char ch[10];cin>>&ch[2];

scanf(“%c”,ch[1]);

scanf(“%s”,&ch);

cin>>ch;

下面程序的输出结果是( )。

#include

using namespace std;

int main()

{

int x[6]={1,3,5,7,9,11},*k,**s;

k=x;

s=&k;

cout<<*(k++)<<","<<**s<<endl;

return 0;

}

3,3
喵查答案：

1,1

3,5

1,3

要定义整型数组x，使之包括初值为0的三个元素，下列语句中错误的是（）。

int x[3]={0，0，0}；
喵查答案：

int x[]={0}；

Static int x[3]={0)；

int x[]={0，0，0)；

下列关于运算符重载的描述中，正确的是（）。
喵查答案：

运算符重载为成员函数时，若参数表中无参数，重载的是一元运算符

一元运算符只能作为成员函数重载

二元运算符重载为非成员函数时，参数表中有一个参数

C++中可以重载所有的运算符

对于常成员函数，下面描述正确的是( )。

常成员函数只能修改常数据成员

常成员函数只能修改一般数据成员
喵查答案：

常成员函数不能修改任何数据成员

常成员函数只能通过常对象调用

语句ofstream f(“DATA.DAT”,ios_base::app|ios_base::binary);的功能是建立流对象f,并试图打开文件DATA.DAT并与之连接，而且( )。

若文件存在，将文件指针定位于文件首；若文件不存在，建立一个新文件

若文件存在，将其截为空文件；若文件不存在，打开失败
喵查答案：

若文件存在，将文件指针定位于文件尾；若文件不存在，建立一个新文件

若文件存在，打开失败；若文件不存在，建立一个新文件

下面程序的输出结果是( )。

#include

using std::cout; using std::endl;

template

T max(T x,T y)

{return(x>=y)?x:y;}

template

T max(T x,T y,T z)

{T t; t=(x>=y)?x:y;

return (t>=z)?t:z;}

int main( )

{ int x=10,y=18,max1;

float a=1.2,b=3.2,c=2,max2;

max1=max(x,(int)c);

max2=max(a,b,(float)y);

cout<<max1<<endl;

cout<<max2<<endl; }

3.2
喵查答案：

3.2

编译出错

关于成员函数的重载，说法正确的是( )。

就是在类中设计多个函数名相同，参数个数及参数类型也相同的函数

析构函数可以重载
喵查答案：

函数重载，要求函数名相同，但参数个数不同，或参数相同，但其类型不同

构造函数不可重载

下面关于转换函数重载的说法正确的是( )。

转换函数的重载与普通函数的重载是一样的，也是靠函数的参数的个数和类型来区别不同的函数

转换函数没有参数，因此不能重载，否则将发生二义性
喵查答案：

转换函数虽然没有参数，但可以依靠函数的类型区别，所以可以重载

对转换函数进行调用时，必须使用强制类型转换以指明调用的是哪个转换函数

有以下程序

#include

using namespace std;

class MyClass

{

public:

MyClass(int n) {number=n;}

//拷贝构造函数

MyClass(MyClass&other){number=other.number;}

~MyClass(){}

private:

int number;

};

MyClass fun(MyClass p)

{

MyClass temp(p);

return temp;

}

int main()

{

MyClass obj1(10),obj2(0);

MyClass obj3(obj1);

obj2=fun(obj3);

return 0;

}

程序执行时，MyClass类的拷贝构造函数被调用的次数是（）。
5
喵查答案：4
3
3

有以下类定义

class MyClass

{

public:

MyClass() { cout<<1;}

};

int main()

{

MyClass a;

MyClass b[2];

MyClass *p[2];

}

执行语句 MyClass a,b[2],*p[2]；后，程序的输出结果是（）。
11
喵查答案：111
1111
11111

有以下程序

#include

using namespace std;

int i=0;

void fun()

{{

static int i =1;

std::cout<<i++<<',';

}

std::cout<<i<<',';

}

int main()

{

fun();fun();

return 0;

}

程序执行后的输出结果是（）。

1，2，1，2
1，2，2，3
2，0，3，0
喵查答案：1，0，2，0

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

#include

using namespace std;

int main()

{

char a[]=”Hello,World”;

char *ptr=a;

while(*ptr)

{

if(*ptr>=’a’&&*ptr<='z')

cout<<char(*ptr+'A'-'a');

else cout<<*ptr;

ptr++;

}

return 0;

}
喵查答案：HELLO,WORLD

Hello,World

hELLO, wORLD

hello,world

下面程序的输出结果是( )。

#include

using namespace std;

int main( )

{ int num=0;

while(num<=2)

{num++;cout<<num<<endl;}

}

4
喵查答案：

2
1

下列程序的输出结果是( )。

#include

using namespace std;

int main( )

{ int a=10,y=0;

do{a+=2;y+=a;

cout<<"a="<<a<<" y="<<y<<endl;

if(y>20) break;

}while(y=14);

cout<>1/a>>2 “<>1)/(a>>2)<<endl;

}
a=12   y=12a=14   y=16a=16   y=20a=18   y=24y>>1/a>>24
喵查答案：a=12   y=12a=14   y=28y>>1/a>2 4
a=12   y=12a=14   y=26a=14   y=44y>>1/a>>2   4.666667
a=12   y=12y>>1/a>>2   4

下面程序的输出结果是( )。

#include

using namespace std;

int main()

{

int a=2,b=-1,c=2;

if(a<b)

if(b<0) c=0;

else c += 1;

cout<<c<<endl;}

0
1
喵查答案：2
3

有以下程序

#include

using namespace std;

class Complex

{

public:

Complex(double r=0,double i=0):re(r),im(i){}

double real() const {return re;}

double imag() const {return im;}

Complex operator +(Complex c) const

{return Complex(re+c.re,im+c.im);}

private:

double re,im;

};

int main()

{

Complex a=Complex(1,1)+Complex(5);

cout << a.real()<<"+"<<a.imag()<<'i'<<endl;

return 0;

}

程序执行后的输出结果是( )。

6+6i
喵查答案：6+1i

1+6i

1+1i

有以下类定义

class MyClass

{

private:

int id;

char gender;

char *phone;

public:

MyClass():id(0),gender(‘#’),phone(NULL){}

MyClass(int no,char ge=’#’,char *ph=NULL)

{id=no;gender=ge;phone=ph;}

};

下列类对象定义语句中错误的是( )。
MyClass myObj;
喵查答案：MyClass myObj(11,”13301111155″);
MyClass myObj(12,’m’);
MyClass myObj(12);

有以下类定义

#include

using namespace std;

class Point{

public:

Point(int x=0,int y=0){_x=x;_y=y;}

void Move(int xOff,int yOff)

{_x +=xOff;_y+=yOff;}

void Print() const

{cout <<'('<<_x<<','<<_y<<')'<<endl;}

private:

int _x,_y;

};

下列语句中会发生编译错误的是( )。

Point pt; pt.Print();

const Point pt;pt.Print();

Point pt;pt.Move(1,2);
喵查答案：

const Point pt; pt.Move(1,2);

执行语句序列

ofstream outfile(“DATE.DAT”);

if (…) cout <<"OK"; else cout<<"FAIL";后，如果文件打开成功显示“OK”，否则就显示“FAIL”。由此可知，上面if语句的…处的表达式应是( )。
coutfile.fail()或outfile

outfile.good()或!outfile

喵查答案：

outfile.good()或outfile

outfile.fail()或!outfile

在下面的运算符重载函数的原型中，错误的是（）。
喵查答案：

Volume operator-(double,double);

double Volume::operator-(double);

Volume Volume::operator-(Volume);

Volume operator-(Volume,Volume);

面向对象程序设计期中考试

1 下面程序的输出结果是( )。#include #include using namespace std;int main( ){ char name[2][6]; strcpy(name[0],”zhang”); strcpy(name[1],”san”); cout<<name[0]<<" "<<name[1]<<endl;}
喵查答案：zhang san
zhang
san
出错

2 下列程序的输出结果是( )。#includeusing namespace std;int main(){char a[]=”Hello,World”;char *ptr=a;while(*ptr){ if(*ptr>=’a’&&*ptr<='z') cout<<char(*ptr+'A'-'a'); else cout<<*ptr; ptr++;} return 0; }
喵查答案：HELLO,WORLD
Hello,World
hELLO, wORLD
hello,world

3 关于成员函数的重载，说法正确的是( )。
就是在类中设计多个函数名相同，参数个数及参数类型也相同的函数
析构函数可以重载
喵查答案：函数重载，要求函数名相同，但参数个数不同，或参数相同，但其类型不同
构造函数不可重载

4 下列关于二维数组的初始化不正确的是( )。
喵查答案：int a[2][ ]={1,2,3};
static int a[2][3]={1,2,3};
static int a[2][3]={{1},{2}};
int a[2][3]={{2}};

5 若有定义：”int a[10],*p;p=a;”则执行”p=p+5;”后，与*p不相等的是( )。
a[5]
*(a+5)
*(p+5)或p[5]
喵查答案：执行“a=a+5;”后的*a

6 下列说法中正确的是( )。
喵查答案：类中的函数成员可以在类体中定义，也可以在类体之外定义
类定义中只能说明函数成员的函数头，不能定义函数体
类中的函数成员在类体之外定义时必须要与类声明在同一文件中
在类体之外定义的函数成员不能操作该类的私有数据成员

7 对象的创建可以在定义类的同时创建对象，也可在使用对象时创建，关于这两种说法正确的是( )。
喵查答案：后者创建的对象的生存期也是整个程序
前者创建的对象是全局对象。后者创建的对象是局部性的
前者创建的对象的作用域是整个程序。后者创建的对象的作用域是所在的函数
前者创建的对象在整个程序运行期间都可被调用

8 以下叙述中正确的是( )。
喵查答案：在类中，不作特别说明的数据成员均为私有类型
在类中，不作特别说明的数据成员均为公有类型
类成员的定义必须是成员变量在前、成员函数在后
类成员的定义必须放在类定义体内部

9 #includeusing namespace std;int a[8]={1,2,3,4,5,6,7};void fun(int *pa,int n);int main(){ int m=8; fun(a,m); cout<<a[7]<<endl; } void fun(int *pa,int n){ for (int I=0;I<n-1;I++) *(pa+7)+= *(pa+I);}程序的执行结果为( )。
喵查答案：28
30
25
12

10 有以下类定义 class MyClass { public: MyClass() { cout<<1;} };执行语句 MyClass a,b[2],*p[2]；后，程序的输出结果是( )。
喵查答案：111
11
1111
11111

11 关于面向对象的程序设计方法，下列说法正确的是( )。
喵查答案：在面向对象的程序设计中，结构化程序设计方法仍有着重要作用
“封装性”指的是将不同类型的相关数据组合在一起，作为一个整体进行处理
“多态性”指的是对象的状态会根据运行时要求自动变化
基类的私有成员在派生类的对象中不可访问，也不占内存空间

12 以下有关成员函数特征的叙述不正确的是( )。
喵查答案：成员函数一定是内联函数
成员函数可以重载
成员函数可以设置缺省数值
成员函数可以是静态的

13 下列关于C++与C语言关系的描述中错误的是( )。
C++是C语言的超集
C++对C语言进行了扩充
C++包含C语言的全部语法特性
喵查答案：C++与C语言都是面向对象的程序设计语言

14 下列( )是函数的声明。
float func ( );
float func ( float x,float y ) {…..}
喵查答案：float func (float,float );
float func(x,y);

15 关于函数的调用下面不正确的是( )。
喵查答案：由于程序总是从主函数开始，所以函数的调用总是在主函数和其他函数之间进行
函数的调用可以在任意函数之间进行，只要有需要
一个函数可以自己调用自己
函数返回时可以不必带返回值，这时函数在定义时其类型应用void标示

16 已知：p是一个指向类A数据成员m的指针，A1是类A的一个对象。如果要给m赋值为5，正确的是( )。
A1.p=5;
A1->p=5;
喵查答案：A1.*p=5;
*A1.p=5;

17 下列关于类型转换的说法中，错误的是( )。
如果a为int 型变量，b为char型变量，则a+b的值为int型
如果a为float 型变量，b为int型变量，则a-b的值为float型
如果a为double 型变量，b为float型变量，则a*b的值为double型
喵查答案：如果a为int 型变量，b为int型变量，则a/(double)b的值为int型

18 关于动态存储分配，下列说法正确的是( )。
new 和 delete是 C++语言中专门用于动态内存分配和释放的函数
喵查答案：动态分配的内存空间也可以被初始化
当系统内存不够时，会自动回收不再使用的内存单元，因此程序中不必要使用delete释放内存空间
当动态分配内存失败时，系统回立刻崩溃，因此一定要谨慎使用 new

19 下列程序的输出结果是(     )。#includeusing namespace std;int main( ){ int a=10,y=0;  do{a+=2;y+=a;   cout<<"a="<<a<<" y="<<y<20) break;   }while(y=14);  cout<>1/a>>2 “<>1)/(a>>2)<>1/a>>24
喵查答案：a=12  y=12a=14  y=28y>>1/a>2 4
a=12  y=12a=14  y=26a=14  y=44y>>1/a>>2  4.666667
a=12  y=12y>>1/a>>2  4

20 下面程序的输出结果是( )。#includeusing namespace std;int main( ){ int a[3][3]={{1,2},{3,4},{5}}; int s=0; for(int i=1;i<3;i++) for(int j=0;j<=i;j++) s+=a[i][j]; cout<<s<<endl;}
喵查答案：12
14
15
13

21 下面程序的输出结果是( )。#include #include using namespace std;int main( ){ char name[2][6]; strcpy(name[0],”zhang”); strcpy(name[1],”san”); cout<<name[0]<<" "<<name[1]<<endl;}
喵查答案：zhang san
zhang
san
出错

22 下列程序的输出结果是( )。#includeusing namespace std;int main(){char a[]=”Hello,World”;char *ptr=a;while(*ptr){ if(*ptr>=’a’&&*ptr<='z') cout<<char(*ptr+'A'-'a'); else cout<<*ptr; ptr++;} return 0; }
喵查答案：HELLO,WORLD
Hello,World
hELLO, wORLD
hello,world

23 关于成员函数的重载，说法正确的是( )。
就是在类中设计多个函数名相同，参数个数及参数类型也相同的函数
析构函数可以重载
喵查答案：函数重载，要求函数名相同，但参数个数不同，或参数相同，但其类型不同
构造函数不可重载

24 下列关于二维数组的初始化不正确的是( )。
喵查答案：int a[2][ ]={1,2,3};
static int a[2][3]={1,2,3};
static int a[2][3]={{1},{2}};
int a[2][3]={{2}};

25 若有定义：”int a[10],*p;p=a;”则执行”p=p+5;”后，与*p不相等的是( )。
a[5]
*(a+5)
*(p+5)或p[5]
喵查答案：执行“a=a+5;”后的*a

26 下列说法中正确的是( )。
喵查答案：类中的函数成员可以在类体中定义，也可以在类体之外定义
类定义中只能说明函数成员的函数头，不能定义函数体
类中的函数成员在类体之外定义时必须要与类声明在同一文件中
在类体之外定义的函数成员不能操作该类的私有数据成员

27 对象的创建可以在定义类的同时创建对象，也可在使用对象时创建，关于这两种说法正确的是( )。
喵查答案：后者创建的对象的生存期也是整个程序
前者创建的对象是全局对象。后者创建的对象是局部性的
前者创建的对象的作用域是整个程序。后者创建的对象的作用域是所在的函数
前者创建的对象在整个程序运行期间都可被调用

28 以下叙述中正确的是( )。
喵查答案：在类中，不作特别说明的数据成员均为私有类型
在类中，不作特别说明的数据成员均为公有类型
类成员的定义必须是成员变量在前、成员函数在后
类成员的定义必须放在类定义体内部

29 #includeusing namespace std;int a[8]={1,2,3,4,5,6,7};void fun(int *pa,int n);int main(){ int m=8; fun(a,m); cout<<a[7]<<endl; } void fun(int *pa,int n){ for (int I=0;I<n-1;I++) *(pa+7)+= *(pa+I);}程序的执行结果为( )。
喵查答案：28
30
25
12

30 有以下类定义 class MyClass { public: MyClass() { cout<<1;} };执行语句 MyClass a,b[2],*p[2]；后，程序的输出结果是( )。
喵查答案：111
11
1111
11111

31 关于面向对象的程序设计方法，下列说法正确的是( )。
喵查答案：在面向对象的程序设计中，结构化程序设计方法仍有着重要作用
“封装性”指的是将不同类型的相关数据组合在一起，作为一个整体进行处理
“多态性”指的是对象的状态会根据运行时要求自动变化
基类的私有成员在派生类的对象中不可访问，也不占内存空间

32 以下有关成员函数特征的叙述不正确的是( )。
喵查答案：成员函数一定是内联函数
成员函数可以重载
成员函数可以设置缺省数值
成员函数可以是静态的

33 下列关于C++与C语言关系的描述中错误的是( )。
C++是C语言的超集
C++对C语言进行了扩充
C++包含C语言的全部语法特性
喵查答案：C++与C语言都是面向对象的程序设计语言

34 下列( )是函数的声明。
float func ( );
float func ( float x,float y ) {…..}
喵查答案：float func (float,float );
float func(x,y);

35 关于函数的调用下面不正确的是( )。
喵查答案：由于程序总是从主函数开始，所以函数的调用总是在主函数和其他函数之间进行
函数的调用可以在任意函数之间进行，只要有需要
一个函数可以自己调用自己
函数返回时可以不必带返回值，这时函数在定义时其类型应用void标示

36 已知：p是一个指向类A数据成员m的指针，A1是类A的一个对象。如果要给m赋值为5，正确的是( )。
A1.p=5;
A1->p=5;
喵查答案：A1.*p=5;
*A1.p=5;

37 下列关于类型转换的说法中，错误的是( )。
如果a为int 型变量，b为char型变量，则a+b的值为int型
如果a为float 型变量，b为int型变量，则a-b的值为float型
如果a为double 型变量，b为float型变量，则a*b的值为double型
喵查答案：如果a为int 型变量，b为int型变量，则a/(double)b的值为int型

38 关于动态存储分配，下列说法正确的是( )。
new 和 delete是 C++语言中专门用于动态内存分配和释放的函数
喵查答案：动态分配的内存空间也可以被初始化
当系统内存不够时，会自动回收不再使用的内存单元，因此程序中不必要使用delete释放内存空间
当动态分配内存失败时，系统回立刻崩溃，因此一定要谨慎使用 new

39 下列程序的输出结果是(     )。#includeusing namespace std;int main( ){ int a=10,y=0;  do{a+=2;y+=a;   cout<<"a="<<a<<" y="<<y<20) break;   }while(y=14);  cout<>1/a>>2 “<>1)/(a>>2)<>1/a>>24
喵查答案：a=12  y=12a=14  y=28y>>1/a>2 4
a=12  y=12a=14  y=26a=14  y=44y>>1/a>>2  4.666667
a=12  y=12y>>1/a>>2  4

40 下面程序的输出结果是( )。#includeusing namespace std;int main( ){ int a[3][3]={{1,2},{3,4},{5}}; int s=0; for(int i=1;i<3;i++) for(int j=0;j<=i;j++) s+=a[i][j]; cout<<s<<endl;}
喵查答案：12
14
15
13

41 下列关于形参的说法正确的是( )。
函数的形参并非是必须的，有时可以不要，这时其函数头如fun( )
函数的形参可以是表达式
喵查答案：函数在定义时，形参是不占用存储空间的，只是在被调用时才会占，调用完毕也就被释放了
形参的名称、类型、数量、顺序必须与实参都相同，否则实参不会把信息正确的传递给形参

42 给出下面定义：char a[ ]=”qwer”;char b[ ]={‘q’,’w’,’e’,’r’};则下面说法正确的是( )。
数组a和数组b等价
数组a和数组b的长度相同
喵查答案：数组a的长度大于数组b的长度
数组a的长度小于数组b的长度

43 以下有关构造函数的叙述不正确的是( )。
喵查答案：在一个类中构造函数有且仅有一个
构造函数名必须和类名一致
构造函数在定义对象是自动执行
构造函数无任何函数类型

44 已知函数f的原型是：void f(int *a,long &b);，变量v1、v2的定义是；int v1; long v2;，正确的调用语句是( )。
f(v1,&v2);
f(v1,v2);
喵查答案：f(&v1,v2);
f(&v1,&v2);

45 执行语句序列ofstream outfile(“DATE.DAT”);if (…) cout <<"OK"; else cout<<"FAIL";后，如果文件打开成功显示“OK”，否则就显示“FAIL"。由此可知，上面if语句的…处的表达式应是( )。
coutfile.fail() 或 outfile
outfile.good() 或 !outfile
喵查答案：outfile.good() 或 outfile
outfile.fail() 或 !outfile

46 下列程序无错的是(   )。
int sum(int a,int b){int sum; sum=a+b;}
void sum(int a,int b){int sum; sum=a+b;return(sum);}
喵查答案：#includeMax(int a,int b){int c;  return(c=a>=b?a:b);}  int main( ){cout<<max(5,6);}
float fun(void){ cout<<"Hello!Everyone";  float fun1( ){ cout<<"Please sit down";}}

47 为避免指针使用上的错误，可以在定义指针时就给指针一个值，这叫指针的初始化，下列不能初始化指针的值是( )。
喵查答案：5
0
NULL
地址

48 下面程序的输出结果是( )。#includeusing namespace std;int main(){ int x[6]={1,3,5,7,9,11},*k,**s; k=x; s=&k; cout<<*(k++)<<","<<**s<<endl; return 0;}
3,3
喵查答案：1,1
3,5
1,3

49 已知程序中已经定义了函数test，其原型是 int test(int,int,int);，则下列重载形式中正确的是( )。
char test (int,int,int);
喵查答案：double test(int,int,double);
int test(int,int,int=0);
float test(int,int,float=3.5F);

50 对于int *pa[5];的描述，正确的是( )。
pa是一个指向数组的指针，所指向的数组是5个int型元素
pa[5]表示某个数组的第5个元素的值
pa是一个指向某个数组中第5个元素的指针，该元素是int型变量
喵查答案：pa是一个具有5个元素的指针数组，每个元素是一个int型指针

51 关于字符串和字符的关系正确的是( )。
“A”与’A’是相同的
字符串是常量，字符是变量
喵查答案：“A”与’A’是不相同的
“A “与”A”是相同的

52 下列函数原型声明中错误的是( )。
void Fun(int x=0,int y=0);
void Fun(int x,int y);
void Fun(int x,int y=0);
喵查答案：void Fun(int x=0,int y)

53 使用const 语句定义一个标识符常量时,则必须对它同时进行初始化。
喵查答案：正确
错误

54 在C++中用new分配的内存空间，在不需要时一般用free将该空间释放。
正确
喵查答案：错误

55 const int *p; 表示不能通过p修改其指向的量，即不允许做”*p=…”操作。
喵查答案：正确
错误

56 在用class定义一个类时，数椐成员和成员函数默认的访问权限是public。
正确
喵查答案：错误

57 定义全局变量时前面加上static，表示定义静态变量。
正确
喵查答案：错误

58 引用就是某个变量的别名，对引用的操作，实质上就是对被引用的变量的操作。
喵查答案：正确
错误

59 重载函数要求函数有相同的函数名，但具有不同的参数序列。
喵查答案：正确
错误

60 内联函数中可以出现递归语句。
正确
喵查答案：错误

61 C++语言规定，函数返回值的类型是由调用该函数时的主调函数类型决定的。
正确
喵查答案：错误

62 作用域运算符(::)只能用来限定成员函数所属的类。
正确
喵查答案：错误

63 说明或定义对象时，类名前面不需要加class关键字。
喵查答案：正确
错误

64 对空指针不能用delete运算符。
正确
喵查答案：错误

65 任何一个对象只能属于一个具体的类。
喵查答案：正确
错误

面向对象程序设计期末综合测评

1 关于析构函数的说法，正确的是（）
喵查答案：析构函数用来释放构造函数为对象分配的内存空间。它可以被调用，也可以被系统自动调用
析构函数没有数据类型，其返回值为隐含型
析构函数可以没有参数，也可以有多个函数
析构函数与构造函数不一样，它可以有多个，以方便使用

2 多态可以被描绘成（）
喵查答案：在一个接口上隐藏多个不同实现的形态
继承
信息放置形态
泛化

3 如果表达式++a中的“++”是作为成员函数重载的运算符，若采用运算符函数调用格式，则可表示为（）
喵查答案：a.operator++( )
a.operator++(1)
operator++(a)
operator++(a,1)

4 下列运算符不能重载的是（）
喵查答案：sizeof
!
new
delete

5 在面向对象的程序设计中，首先在问题域中识别出若干个（）
喵查答案：类
函数
文件
过程

6 已知f1和f2是同一类的两个成员函数，但f1不能直接调用f2，这说明（）
喵查答案：f1是静态函数，f2不是静态函数
f1和f2都是静态函数
f1不是静态函数，f2是静态函数
f1和f2都不是静态函数

7 若Sample类中的一个成员函数说明如下：void set(Sample& a)，则Sample& a的含义是（）
喵查答案：a是类Sample的对象引用，用来作函数Set（）的形参
指向类Sample的名为a的指针
将a的地址赋给变量Set
变量Sample与a按位与的结果作为函数Set的参数

8 有如下程序： #include using namespace std; class MyClass{ public: MyClass() { cout<< '*'; } MyClass(MyClass& a){ cout<< '#'; } ~ MyClass(){ cout<< '@'; }};int main(){ MyClass a; MyClass b(a); return 0;}运行时的输出结果是（）
喵查答案：*#@@
#@*@
*@#@
#*@@

9 假定一个类的构造函数为A(int aa,int bb){a=aa++;b=a*++bb;}，则执行A x(4,5);语句后，x.a和x.b的值分别为( )
喵查答案：4和2
4和5
4和20
20和5

10 对使用关键字new所开辟的动态存储空间，释放时必须使用（）
喵查答案：delete
free
create
realse

11 如果没有为一个类定义任何构造函数的情况下，下列描述正确的是（）
喵查答案：编译器总是自动创建一个不带参数的构造函数
这个类没有构造函数
这个类不需要构造函数
该类不能通过编译

12 下列合法的标志符为（）。
abde+
67KDJ
#KSJF
喵查答案：DK3

13 下面程序的输出结果是（）。#includeusing namespace std;int main(){ int x[6]={1,3,5,7,9,11},*k,**s; k=x; s=&k; cout<<*(k++)<<","<<**s<<endl; return 0;}
3,3
喵查答案：1,1
3,5
1,3

14 下列程序的运行结果为（）。#includeusing namespace std;class a{public:a(int i=10){x=i;cout<<"a:"<<x<<endl;}int x;};class b:public a{public:b(int i):A(i){x=i;cout<<"b:"<<x<<"，"<<a::x<<endl;}private:a A;int x;};int main(){ b B(5);return 0;}
喵查答案：a:10a:5b:5，10
a:5b:5，10
a:5b:5，10a:10
a:5a:10b:5，10

15 设有“int a[3][5];”,其按列排列，则与a[2][1]位置相同的按行排列的元素是（）。
a[2][1]
喵查答案：a[1][0]
a[1][4]
a[2][3]

16 下列语句中，错误的是（）。
const int buffer＝256；
const double *point；
int const buffer＝256；
喵查答案：double * const point；

17 有如下程序段：int i=0,j=1;int &r=i; //①r=j; //②int *p=&i; //③*p=&r; //④其中会产生编译错误的语句是（）。
喵查答案：④
③
②
①

18 有如下程序：#includeusing namespace std;class AA{public: virtual void f(){cout<<"AA";}};class BB:public AA{public: BB(){cout<<"BB";}};class CC:public BB{public: virtual void f(){BB::f();cout<f();return 0;}执行上面的程序将输出（）
喵查答案：BBBBAACC
BBAACC
AABBCC
BBAABBCC

19 在定义函数模板或类模板时，开头的保留字是（）
喵查答案：template
typename
class
typedef

20 若需要向一个二进制文件尾部添加数据，则该文件的打开方式为（）
喵查答案：ios_base::binary | ios_base::app
ios_base::out
ios_base::binary | ios_base::out
ios_base::app

21 关于析构函数的说法，正确的是（）
喵查答案：析构函数用来释放构造函数为对象分配的内存空间。它可以被调用，也可以被系统自动调用
析构函数没有数据类型，其返回值为隐含型
析构函数可以没有参数，也可以有多个函数
析构函数与构造函数不一样，它可以有多个，以方便使用

22 多态可以被描绘成（）
喵查答案：在一个接口上隐藏多个不同实现的形态
继承
信息放置形态
泛化

23 如果表达式++a中的“++”是作为成员函数重载的运算符，若采用运算符函数调用格式，则可表示为（）
喵查答案：a.operator++( )
a.operator++(1)
operator++(a)
operator++(a,1)

24 下列运算符不能重载的是（）
喵查答案：sizeof
!
new
delete

25 在面向对象的程序设计中，首先在问题域中识别出若干个（）
喵查答案：类
函数
文件
过程

26 已知f1和f2是同一类的两个成员函数，但f1不能直接调用f2，这说明（）
喵查答案：f1是静态函数，f2不是静态函数
f1和f2都是静态函数
f1不是静态函数，f2是静态函数
f1和f2都不是静态函数

27 若Sample类中的一个成员函数说明如下：void set(Sample& a)，则Sample& a的含义是（）
喵查答案：a是类Sample的对象引用，用来作函数Set（）的形参
指向类Sample的名为a的指针
将a的地址赋给变量Set
变量Sample与a按位与的结果作为函数Set的参数

28 有如下程序： #include using namespace std; class MyClass{ public: MyClass() { cout<< '*'; } MyClass(MyClass& a){ cout<< '#'; } ~ MyClass(){ cout<< '@'; }};int main(){ MyClass a; MyClass b(a); return 0;}运行时的输出结果是（）
喵查答案：*#@@
#@*@
*@#@
#*@@

29 假定一个类的构造函数为A(int aa,int bb){a=aa++;b=a*++bb;}，则执行A x(4,5);语句后，x.a和x.b的值分别为( )
喵查答案：4和2
4和5
4和20
20和5

30 对使用关键字new所开辟的动态存储空间，释放时必须使用（）
喵查答案：delete
free
create
realse

31 如果没有为一个类定义任何构造函数的情况下，下列描述正确的是（）
喵查答案：编译器总是自动创建一个不带参数的构造函数
这个类没有构造函数
这个类不需要构造函数
该类不能通过编译

32 下列合法的标志符为（）。
abde+
67KDJ
#KSJF
喵查答案：DK3

33 下面程序的输出结果是（）。#includeusing namespace std;int main(){ int x[6]={1,3,5,7,9,11},*k,**s; k=x; s=&k; cout<<*(k++)<<","<<**s<<endl; return 0;}
3,3
喵查答案：1,1
3,5
1,3

34 下列程序的运行结果为（）。#includeusing namespace std;class a{public:a(int i=10){x=i;cout<<"a:"<<x<<endl;}int x;};class b:public a{public:b(int i):A(i){x=i;cout<<"b:"<<x<<"，"<<a::x<<endl;}private:a A;int x;};int main(){ b B(5);return 0;}
喵查答案：a:10a:5b:5，10
a:5b:5，10
a:5b:5，10a:10
a:5a:10b:5，10

35 设有“int a[3][5];”,其按列排列，则与a[2][1]位置相同的按行排列的元素是（）。
a[2][1]
喵查答案：a[1][0]
a[1][4]
a[2][3]

36 下列语句中，错误的是（）。
const int buffer＝256；
const double *point；
int const buffer＝256；
喵查答案：double * const point；

37 有如下程序段：int i=0,j=1;int &r=i; //①r=j; //②int *p=&i; //③*p=&r; //④其中会产生编译错误的语句是（）。
喵查答案：④
③
②
①

38 有如下程序：#includeusing namespace std;class AA{public: virtual void f(){cout<<"AA";}};class BB:public AA{public: BB(){cout<<"BB";}};class CC:public BB{public: virtual void f(){BB::f();cout<f();return 0;}执行上面的程序将输出（）
喵查答案：BBBBAACC
BBAACC
AABBCC
BBAABBCC

39 在定义函数模板或类模板时，开头的保留字是（）
喵查答案：template
typename
class
typedef

40 若需要向一个二进制文件尾部添加数据，则该文件的打开方式为（）
喵查答案：ios_base::binary | ios_base::app
ios_base::out
ios_base::binary | ios_base::out
ios_base::app

41 下列程序运行的结果为：（）。#includeusing namespace std;int main(){char a[]=”Hello,World”;char *ptr=a;while(*ptr){ if(*ptr>=’a’&&*ptr<='z') cout<<char(*ptr+'A'-'a'); else cout<<*ptr; ptr++;} return 0;}
喵查答案：HELLO,WORLD
Hello,World
hELLO, wORLD
hello,world

42 不能把字符串“hello!”赋给数组b的语句是（）。
char b[10]={‘h’,’e’,’1′,’1′,’o’,’!’,’10’}
喵查答案：char b[10]; b=”hello”
char b[10]; strcpy(b,”hello!”)
char b[10]=”hello!”

43 int Func(int，int)；不可与下列哪个函数构成重载（）
喵查答案：double Func(int，int)；
int Func(int，int，int)；
double Func(double，double)；
double Func(int，double)；

44 使用地址作为实参传给形参，下列说法正确的是（）
喵查答案：实参与形参是同一对象
实参是形参的备份
实参与形参无联系
形参是实参的备份

45 下列程序的输出结果是（）#include void main(){ int n［］［3］={10,20,30,40,50,60}; int (*p)［3］; p=n; cout<<p［0］［0］<<"，"<<*(p［0］+1)<<"，"<<(*p)［2］<<endl;}
喵查答案：10，20，30
10，30，50
20，40，60
10，30，60

46 已知：p是一个指向类A数据成员m的指针，A1是类A的一个对象。如果要给m赋值为5，正确的是（）
喵查答案：A1.*p=5;
A1.p=5;
A1->p=5;
*A1.p=5;

47 带有虚基类的多层派生类构造函数的成员初始化列表中都要列出虚基类的构造函数，这样将对虚基类的子对象初始化（）
喵查答案：一次
与虚基类下面的派生类个数有关
二次
多次

48 以下对C++语言函数的有关描述中，正确的是（）
喵查答案：在C++中，调用函数时，只能把实参的值传送给形参，形参的值不能传送给实参
C++函数既可以嵌套定义又可以递归调用
函数必须有返回值，否则不能使用函数
C++程序中有调用关系的所有函数必须放在同一个源程序文件中

49 已知类MyClass的定义如下：class MyClass{public: MyClass（int d）{data=d;} ~MyClass( ) {}private: int data;};下列对MyClass类对象数组的定义和初始化语句中，正确的是（）
喵查答案：MyClass arrays[2] = { MyClass (5), MyClass (6)};
MyClass arrays[2];
MyClass arrays[2] = { MyClass (5)};
MyClass *arrays = new MyClass[2];

50 有如下程序：#includeusing namespace std;class Base1{public: Base1(int d){cout<<d;} ~Base1(){}};class Base2{public: Base2(int d){cout<<d;} ~Base2(){}};class Derived : public Base1,Base2{public: Derived(int a,int b,int c,int d):Base1(b),Base2(a),b1(c),b2(d){}private: int b1; int b2;}; int main(){ Derived d(1,2,3,4); system("pause"); return 0;}运行时的输出结果是（）
喵查答案：21
12
1234
123

51 有如下程序：#include using namespace std;class Base{public: virtual void function1() { cout<<'0'; } void function2() { cout<<'1'; }};class Derived:public Base{public: void function1() { cout<<'2'; } void function2() { cout<function1(); p->function2(); delete p; return 0;}运行时的输出结果是（）
01
喵查答案：21
03
23

52 若为Fraction类重载前增1运算符++，应在类体中将其声明为（）
喵查答案：Fraction& operator ++ （）；
Fraction& operator ++ （int）；
friend Fraction& operator ++ （）；
friend Fraction& operator ++ （int）；

53 有如下程序：#include using namespace std;void function2（int n）;void function1（int n） { if（n<=0）return; funtion2(n-2);}void function2（int n）{ if(n<=0) return;funtion1(n-1);}int main( ){ funtion1(5); return 0;}下列关于程序运行情况的描述中，正确的是（）
喵查答案：funtion1运行2次，funtion2运行2次
funtion1运行1次，funtion2运行2次
funtion1运行2次，funtion2运行1次
funtion1运行2次，funtion2运行3次

54 若需要为XV类重载乘法运算符，运算结果为XV类型，在将其声明为类的成员函数时，下列原型声明正确的是（）
喵查答案：XV operator *(XV);
XV operator *(XV,XV);
XV *(XV);
operator *(XV);

55 关于对象的性质，下列描述错误的是（）
喵查答案：对象不可以用作函数参数
同一类对象间可相互赋值
可以使用对象数组
一个对象可以用作另一个类的成员

56 声明一个没有初始化参数的对象，需调用（）
喵查答案：默认构造函数
指定参数构造函数
拷贝构造函数
初始化函数

57 下列关于类的权限描述错误的是（）
喵查答案：普通函数可以不通过对象直接访问类的公有成员
类本身的成员函数可以访问自身的任何成员
类的对象只能访问公有成员
一个类可以包含另一个类的对象作为成员

58 My是一个类，则执行语句My a［3］，*p［2］之后，自动调用构造函数次数为（）
喵查答案：3
2
4
5

59 下面对析构函数的正确描述是（）
喵查答案：析构函数没有参数
系统不能提供默认的析构函数 B.析构函数必须由用户定义
析构函数必须由用户定义
析构函数可以设置默认参数

60 对于拷贝初始化构造函数和赋值操作的关系，正确的描述是（）
喵查答案：当调用拷贝初始化构造函数时，类的对象正在被建立并被初始化
拷贝初始化构造函数和赋值操作是完全一样的操作
进行赋值操作时，会调用类的构造函数
拷贝初始化构造函数和赋值操作不能在同一个类中被同时定义

61 假定一个类的构造函数为“A(int i=4, int j=0) {a=i;b=j;}”, 则执行“A x (1);”语句后，x.a和x.b的值分别为（）
喵查答案：1和0
1和4
4和0
4和1

62 假定一个类的构造函数为A(int aa,int bb) {a=aa–;b=a*bb;},则执行A x(4,5)；语句后，x.a和x.b的值分别为（）
喵查答案：4和20
3和15
5和4
20和5

63 在定义类成员时，为产生封装性，则需使用哪个关键字（）
喵查答案：private
public
publish
protected

64 类的构造函数在以下什么情况下会被自动调用（）
喵查答案：定义对象时
定义成员函数时
定义数据成员时
定义友元函数时

65 下列关于析构函数描述正确的是（）
喵查答案：不能指定返回类型
可以重载
函数体中必须有delete语句
返回类型必须是void类型

66 设有函数T Sum(T x，T y){return x+y；}，其中T为模板类型，则下列语句中对该函数错误的使用是（）
喵查答案：Sum(“A”，”C”)
Sum(3.0，2.2)
Sum(1，2)
Sum(‘A’，‘C’)

67 若Sample类中的一个成员函数说明如下：void set(Sample& a)，则Sample& a的含义是（）
喵查答案：a是类Sample的对象引用，用来作函数Set（）的形参
指向类Sample的名为a的指针
将a的地址赋给变量Set
变量Sample与a按位与的结果作为函数Set的参数

68 已知f1和f2是同一类的两个成员函数，但f1不能直接调用f2，这说明（）
喵查答案：f1是静态函数，f2不是静态函数
f1和f2都是静态函数
f1不是静态函数，f2是静态函数
f1和f2都不是静态函数

69 假定AB为一个类，则执行“AB a(2), b［3］,*p［4］;”语句时调用该类构造函数的次数为（）
喵查答案：4
3
5
9

70 下列描述错误的是（）
喵查答案：在没创建对象前，静态成员不存在
静态成员是类的成员，不是对象成员
静态成员不能是虚函数
静态成员函数不能直接访问非静态成员

71 对每个可重载的运算符来讲，它既可以重载为友元函数，又可以重载为成员函数，还可以重载为非成员函数
正确
喵查答案：错误

72 const char* p说明了p是指向字符串的常量指针。
正确
喵查答案：错误

73 已知：m是类A的对象，n是类A的公有数据成员，p是指向类A中n成员的指针。下述两种表示是等价的：m.n和m.*p
喵查答案：正确
错误

74 所谓私有成员是指只有类中所提供的成员函数才能直接使用它们，任何类以外的函数对它们的访问都是非法的。
正确
喵查答案：错误

75 说明或定义对象时，类名前面不需要加class关键字。
喵查答案：正确
错误

76 作用域运算符(::)只能用来限定成员函数所属的类。
正确
喵查答案：错误

77 在公有继承中，基类的成员在派生类中都可以直接使用。
正确
喵查答案：错误

78 一个类的构造函数可以不包含对其子对象的初始化。
喵查答案：正确
错误

79 构造函数的函数体中，不能使用return语句；但在实现该类的自动类型转化函数时，必须有return 语句。
喵查答案：正确
错误

80 this是一个隐含于每一个类的成员函数的特殊指针，它是一个指向正在被某个成员函数操作的对象的指针。
喵查答案：正确
错误

81 对重载的函数，要求函数类型相同但参数不同。
正确
喵查答案：错误

82 对空指针不能用delete运算符。
正确
喵查答案：错误

83 指向对象数组的指针不一定必须指向数组的首指针。
喵查答案：正确
错误

84 如果派生类没有实现虚函数，那么它将使用它的基类的虚函数。
喵查答案：正确
错误

85 要达到动态联编的效果，基类和派生类的对应函数不仅名字相同，而且返回类型、参数个数和类型也必须相同。
喵查答案：正确
错误

86 无论什么方式的继承，基类的私有成员都不能被派生类访问。
喵查答案：正确
错误

87 在公有继承中，基类中的公有成员和私有成员在派生类中都是可见的。
正确
喵查答案：错误

88 对重载的函数，要求参数不同或函数类型不同。
正确
喵查答案：错误

89 用new运算符来创建对象时不会调用构造函数。
正确
喵查答案：错误

90 任何一个对象只能属于一个具体的类。
喵查答案：正确
错误

/pay

第一部分 面向对象方法与C++概述

第二部分 过程化编程技术-函数应用

第三部分 封装与信息隐藏-类与对象

第四部分 面向对象编程技术-继承与派生

第五部分 面向对象编程技术-多态性

面向对象程序设计期中考试

面向对象程序设计期末综合测评

第一部分面向对象方法与C++概述

第二部分过程化编程技术-函数应用

第三部分封装与信息隐藏-类与对象

第四部分面向对象编程技术-继承与派生

第五部分面向对象编程技术-多态性