中国大学MOOC 面向对象的C++和Windows编程-武汉理工大学测验与作业答案喵查铺子

文章目录[隐藏]

第1章面向对象程序设计（4周）
第2章继承性（2周）
第3章多态性（2周）
第4章泛型程序设计（1周）
第9章设计用户界面（2周）
慕课期末考试

第1章面向对象程序设计（4周）

1 下述程序中语句完全不正确的一组语句是（）class automover ｛ int wheels; float weight; public: void initialize(int, float); int get_wheels(); float get_weight()｛return weight;｝｝; void automover::initialize(int in_wheels, float in_weight) ｛ wheels=in_wheels; weight=in_weight;｝ int automover::get_wheels(void)｛ return wheels; ｝ void main() ｛ automover car; automover.initialize(4, 3000.0); //① car.wheels=4; //② car.weight=3000.0; //③ car.initialize(4, 3000.0); //④ cout<<"\nThe car has "<<car.wheels<<" wheels."; //⑤ cout<<"\nThe car weighs "<<car.weight<<" pounds."; //⑥ cout<<"\nThe car has "<<car.get_wheels()<<" wheels."; //⑦ cout<<"\nThe car weighs "<<car.get_weight()<<" pounds."; //⑧ ｝
①、②、③、④、⑤
喵查答案： ①、②、③、⑤、⑥
②、③、④、⑤、⑥
①、②、④、⑦、⑧

2 （）是不可以作为该类的成员的。
自身类对象的指针
喵查答案：自身类的对象
自身类对象的引用
另一个类的对象

3 类的私有成员可在何处被访问？( )
喵查答案：本类的成员函数中
本类及子类的成员函数中
通过对象名在任何位置
不可访问

4 类的实例化是指（　）。
喵查答案：创建类对象
定义类
调用类的成员
指明具体的类

5 关于对象和类的关系，说法不正确的是（）。
同属于一类的对象，具有相同的数据成员和成员函数
对象是具体，是类的对象，同其他变量一样，先定义后使用
喵查答案：同一类的不同对象，其具有的操作可不同，具体的操作也不同
不同类的对象，可有相同的操作

6 下面关于类概念的描述中，（）是错误的。
类是抽象数据类型的实现
类是具有共同行为的若干对象的统一描述体
类是创建对象的样板
喵查答案：类就是C语言中的结构类型

7 下面关于对象概念的描述中，（）是错误的。
喵查答案：对象就是C语言中的结构变量
对象代表着正在创建的系统中的一个实体
对象是一个状态和操作（或方法）的封装体
对象之间的信息传递是通过消息进行的

8 关于封装，下列说法中不正确的是（）。
通过封装，对象的全部属性和操作结合在一起，形成一个整体
通过封装，一个对象的实现细节被尽可能地隐藏起来（不可见）
通过封装，每个对象都成为相对独立的实体
喵查答案：通过封装，对象的属性都是不可见的

9 在类定义的外部，可以被访问的成员有（）。
所有类成员
private或protected的类成员
喵查答案：public的类成员
public或private的类成员

10 已知类A中的一个成员函数的说明如下:void Set(A &a);则该函数的参数”A &a”的含义是（）。
指向A的指针为a
将变量a的地址赋给类A
喵查答案：类A对象引用a用作函数的形参
变量A与a按位与后作函数参数

11 关于成员函数特征的下述描述中，（）是错误的。
喵查答案：成员函数一定是内联函数
成员函数可以重载
成员函数可以设置参数的缺省值
成员函数可以是静态的

12 假定AA为一个类，int a()为该类的一个成员函数，若该成员函数在类定义体外定义，则函数头为（）。
喵查答案：int AA::a()
int AA:a()
AA::a()
AA::int a()

13 假定AA为一个类，a为该类私有的数据成员，GetValue()为该类公有函数成员，它返回a的值，x为该类的一个对象，则访问x对象中数据成员a的格式为（）。
x.a
x.a()
x->GetValue()
喵查答案：x.GetValue()

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

15 假定AA为一个类，a()为该类公有的函数成员，x为该类的一个对象，则访问x对象中函数成员a()的格式为（）。
x.a
喵查答案：x.a()
x->a
x->a()

16 在类外定义类的成员函数时，应当使用（　　）来标识该函数为特定类的成员。
：
喵查答案：：：
->
this

17 关于类的成员函数，下列说法正确的是（）。
必须在类体内定义
一定是内联函数
不可以重载
喵查答案：可以设置参数的缺省值

18 在C++中，一个函数为void f(int, char ch=’a’)，另一个函数void f(int)，则它们（）。
不能在同一程序中定义
喵查答案：可以在同一程序中定义并可重载
可以在同一程序中定义，但不可以重载
其他三种说法均不正确

19 有如下类声明： class TestClass { int i; private: int j; protected: int k; public: int m,n; };其中，私有成员的数量为( )。
0
1
喵查答案：2
3

20 设有以下类的定义：class Ex { int x; public: void setx(int t=0); };若在类外定义成员函数setx(),以下定义形式中正确的是（）。
void setx(int t) {…}
喵查答案：void Ex::setx(int t) {…}
Ex::void setx(int t) {…}
void Ex::setx(){…}

21 下述程序中语句完全不正确的一组语句是（）class automover ｛ int wheels; float weight; public: void initialize(int, float); int get_wheels(); float get_weight()｛return weight;｝｝; void automover::initialize(int in_wheels, float in_weight) ｛ wheels=in_wheels; weight=in_weight;｝ int automover::get_wheels(void)｛ return wheels; ｝ void main() ｛ automover car; automover.initialize(4, 3000.0); //① car.wheels=4; //② car.weight=3000.0; //③ car.initialize(4, 3000.0); //④ cout<<"\nThe car has "<<car.wheels<<" wheels."; //⑤ cout<<"\nThe car weighs "<<car.weight<<" pounds."; //⑥ cout<<"\nThe car has "<<car.get_wheels()<<" wheels."; //⑦ cout<<"\nThe car weighs "<<car.get_weight()<<" pounds."; //⑧ ｝
①、②、③、④、⑤
喵查答案： ①、②、③、⑤、⑥
②、③、④、⑤、⑥
①、②、④、⑦、⑧

22 （）是不可以作为该类的成员的。
自身类对象的指针
喵查答案：自身类的对象
自身类对象的引用
另一个类的对象

23 类的私有成员可在何处被访问？( )
喵查答案：本类的成员函数中
本类及子类的成员函数中
通过对象名在任何位置
不可访问

24 类的实例化是指（　）。
喵查答案：创建类对象
定义类
调用类的成员
指明具体的类

25 关于对象和类的关系，说法不正确的是（）。
同属于一类的对象，具有相同的数据成员和成员函数
对象是具体，是类的对象，同其他变量一样，先定义后使用
喵查答案：同一类的不同对象，其具有的操作可不同，具体的操作也不同
不同类的对象，可有相同的操作

26 下面关于类概念的描述中，（）是错误的。
类是抽象数据类型的实现
类是具有共同行为的若干对象的统一描述体
类是创建对象的样板
喵查答案：类就是C语言中的结构类型

27 下面关于对象概念的描述中，（）是错误的。
喵查答案：对象就是C语言中的结构变量
对象代表着正在创建的系统中的一个实体
对象是一个状态和操作（或方法）的封装体
对象之间的信息传递是通过消息进行的

28 关于封装，下列说法中不正确的是（）。
通过封装，对象的全部属性和操作结合在一起，形成一个整体
通过封装，一个对象的实现细节被尽可能地隐藏起来（不可见）
通过封装，每个对象都成为相对独立的实体
喵查答案：通过封装，对象的属性都是不可见的

29 在类定义的外部，可以被访问的成员有（）。
所有类成员
private或protected的类成员
喵查答案：public的类成员
public或private的类成员

30 已知类A中的一个成员函数的说明如下:void Set(A &a);则该函数的参数”A &a”的含义是（）。
指向A的指针为a
将变量a的地址赋给类A
喵查答案：类A对象引用a用作函数的形参
变量A与a按位与后作函数参数

31 关于成员函数特征的下述描述中，（）是错误的。
喵查答案：成员函数一定是内联函数
成员函数可以重载
成员函数可以设置参数的缺省值
成员函数可以是静态的

32 假定AA为一个类，int a()为该类的一个成员函数，若该成员函数在类定义体外定义，则函数头为（）。
喵查答案：int AA::a()
int AA:a()
AA::a()
AA::int a()

33 假定AA为一个类，a为该类私有的数据成员，GetValue()为该类公有函数成员，它返回a的值，x为该类的一个对象，则访问x对象中数据成员a的格式为（）。
x.a
x.a()
x->GetValue()
喵查答案：x.GetValue()

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

35 假定AA为一个类，a()为该类公有的函数成员，x为该类的一个对象，则访问x对象中函数成员a()的格式为（）。
x.a
喵查答案：x.a()
x->a
x->a()

36 在类外定义类的成员函数时，应当使用（　　）来标识该函数为特定类的成员。
：
喵查答案：：：
->
this

37 关于类的成员函数，下列说法正确的是（）。
必须在类体内定义
一定是内联函数
不可以重载
喵查答案：可以设置参数的缺省值

38 在C++中，一个函数为void f(int, char ch=’a’)，另一个函数void f(int)，则它们（）。
不能在同一程序中定义
喵查答案：可以在同一程序中定义并可重载
可以在同一程序中定义，但不可以重载
其他三种说法均不正确

39 有如下类声明： class TestClass { int i; private: int j; protected: int k; public: int m,n; };其中，私有成员的数量为( )。
0
1
喵查答案：2
3

40 设有以下类的定义：class Ex { int x; public: void setx(int t=0); };若在类外定义成员函数setx(),以下定义形式中正确的是（）。
void setx(int t) {…}
喵查答案：void Ex::setx(int t) {…}
Ex::void setx(int t) {…}
void Ex::setx(){…}

41 设有以下类和对象的定义:class A {public: int k; }; A x1,x2,*p1,*p2;则下面针对成员变量k的引用，正确的是（）。
x1->k=1;
喵查答案：x2.k=2;
p1.k=3;
(*p2)->k=4;

42 下列关于创建一个int型变量的引用，正确的是（）。
喵查答案：int a(3),&ra=a;
int a(3),&ra=&a;
double d(3.1);int &rd=d;
int a(3),ra=a;

43 下列关于成员函数的描述中，错误的是（）。
喵查答案：成员函数的定义必须在类体外
成员函数可以是公有的，也可以是私有的
成员函数在类体外定义时，前加inline可为内联函数
成员函数可以设置参数的默认值

44 下列程序中说明的公有成员是( )。class Location{ int X; public: void init(int,init X,int init Y); private: int Y; public: int GetX(); int GetY(); };
X
init(int,init X,int init Y)
GetX(),GetY()
喵查答案：init(int init X,int init Y),GetX(),GetY()都是

45 为了使类中的某个成员不能被类的对象通过成员操作符访问，则不能把该成员的访问权限定义为（　　）。
喵查答案：public
protected
private
static

46 在函数的引用调用中，函数的实参和形参分别应是（）。
变量值和变量
地址值和指针
喵查答案：变量名和引用
地址值和引用

47 下面（　　）是函数重载。
喵查答案：void play(int) 和void play(float)
play( ) 和 ~play()
void play(int) 和int play(int)
void play( ) 和int play( )

48 下列选择重载函数的不同实现的判断条件中，错误的是（）。
参数类型不同
参数个数不同
参数顺序不同
喵查答案：函数返回值不同

49 void Set( &a);是类中一个成员函数的说明，其中&a的含义是（）。
喵查答案：类A的对象引用a作该函数的参数
类A的对象a的地址值作函数的参数
表达式变量A与变量a按位与作函数参数
指向类A对象指针a作函数参数

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

51 下列设置函数参数默认值的说明语句中，错误的是（）。其中，a和b是已定义过具有有效值的变量。
int fun(int x , int y=10);
int fun(int x=5, int =10);
喵查答案：int fun(int x=5, int y);
int fun(int x , int y=a+b);

52 下列哪个不是面向对象的特征（）。
抽象性
喵查答案：结构性
封装性
多态性

53 下列关于引用概念的描述中，错误的是（）。
喵查答案：引用是变量，它具有值和地址值
引用不可以作数组元素
引用是变量的别名
创建引用时必须进行初始化

54 下列关于设置函数默认的参数值的描述中，错误的是（）。
可对函数的部分参数或全部参数设置默认值
在有函数说明时，默认值应设置在函数说明时，而不是定义时
喵查答案：设置函数参数默认值应从左向右设置
设置函数参数默认值应从右向左设置

55 下列关于面向对象概念的描述中，错误的是（）。
面向对象方法比面向过程方法更加先进
面向对象方法中使用了一些面向过程方法中没有的概念
喵查答案：面向对象方法替代了结构化程序设计方法
面向对象程序设计方法要使用面向对象的程序设计语言

56 下列关于类和对象的叙述中，错误的是（）。
喵查答案：一个类只能有一个对象
对象是类的具体实例
类是对某一类对象的抽象
类和对象的关系是一种数据类型与变量的关系

57 下列关于类的权限的描述错误的是（）。
喵查答案：类本身的成员函数只能访问自身的私有成员
类的对象只能访问该类的公有成员
普通函数不能直接访问类的公有成员，必须通过对象访问
类本身的成员函数可以访问自身的公有成员

58 下列关于类的描述中，错误的是（）。
喵查答案：类就是C语言中的结构类型
类是创建对象的模板
类是一种抽象数据类型
类是具有共同行为的若干对象的统一描述体

59 下列关于对象的描述中，错误的是（）。
定义对象时系统会自动进行初始化
对象成员的表示与C语言中结构变量的成员表示相同
属于同一个类的对象占有内存字节数相同
喵查答案：一个类所能创建对象的个数是有限制的

60 下列关于对象的描述中，错误的是（）。
对象是类的一个实例
对象是属性和行为的封装体
喵查答案：对象就是C语言中的结构变量
对象是现实世界中客观存在的某种实体

61 p是指向类A数据成员x的指针，a是类A的一个对象。在给x成员赋值为5的下列表达式中，正确的是（）。
a.p=5
a->p=5
喵查答案：a.*p=5
*a.p=5

62 已知：类A中一个成员函数说明如下：void Set(A&a)；其中A &a的含意是将a的地址给变量Set。
正确
喵查答案：错误

63 一个类只能有一个对象。
正确
喵查答案：错误

64 使用class定义的类，其默认的访问权限是公有的，使用struct定义的类，其默认的访问权限是私有的。
正确
喵查答案：错误

65 类中的数据成员不能为指针类型。
正确
喵查答案：错误

66 类中的成员函数都是公有的，数据成员都是私有的。
正确
喵查答案：错误

67 类的公有成员函数是类与外界的接口。
喵查答案：正确
错误

68 定义在类体内的成员函数是内联函数，定义在类体外的成员函数不能是内联函数。
正确
喵查答案：错误

69 定义一个对象时，系统只为该对象的数据成员开辟内存空间，而成员函数是同类对象共享的。
喵查答案：正确
错误

70 定义对象引用时，可以对其引用进行初始化，也可以不进行初始化。
正确
喵查答案：错误

71 成员函数与一般函数一样可以重载、内联和设置参数的默认值。
喵查答案：正确
错误

72 C++语言支持封装性和继承性，不支持多态性。
正确
喵查答案：错误

73 类的私有成员只能被类中的成员函数访问，任何类以外的函数对它们的访问都是非法的。
正确
喵查答案：错误

74 面向对象方法具有封装性、继承性和多态性。
喵查答案：正确
错误

75 在用class定义一个类时,数椐成员和成员函数默认的访问权限是public。
正确
喵查答案：错误

76 在类的定义中，必须包含private、public、protected三种存取方式对应的部分。
正确
喵查答案：错误

77 使用内联函数是以增大空间开销为代价的。
喵查答案：正确
错误

78 函数的参数个数和类型都相同，只是返回值不同,这不是重载函数。
喵查答案：正确
错误

79 自身类对象的引用不可以作为该类的成员。
正确
喵查答案：错误

80 在C++中，定义函数时应该给出函数的返回类型。
喵查答案：正确
错误

81 对象引用作为函数参数比用对象指针更方便些。
喵查答案：正确
错误

82 已知:m是类A的对象，n是类A的公有数据成员，p是指向类A中n成员的指针，则下述两种表示是等价的：m.n和m.*p。
喵查答案：正确
错误

已知一个类Complex，有下述两行：Complex c; //A Complex c();//B

以下描述中，错误的是（）。
A行定义了一个对象，并调用缺省构造函数
喵查答案：B行定义了一个对象，并调用缺省构造函数
B行是一个函数原型说明，函数名为c，函数没有参数，返回值类型为Complex
A和B行的意义不一样

对于如下的类：

class Animal { float weight; int feet; public: Animal(float w,int f=4) {weight=w; feet=f;} };

定义其对象完全正确的一组语句是（）。
Animal a1(3.6, 8); Animal a2;
喵查答案：Animal a1(3.6, 8); Animal a2(67.9);
Animal a1(67.9); Animal a2;
Animal a1(3.6, 8); Animal a2();

3 C++如果某函数的返回值是个对象，则该函数被调用时，返回的对象（）。
喵查答案：是通过复制构造函数初始化的
是通过无参数的构造函数初始化的
用哪个构造函数初始化取决于函数中 return 语句是怎么写的
不需要初始化

4 下面表述错误的是（）。
喵查答案：this指针是字符指针
this指针是当前指针
this指针是隐含指针
this指针是特殊指针

5 有如下程序：#include using namespace std; class ONE { int c; public: ONE(): c(0) { cout<<1; } ONE(int n): c(n) { cout<<2; } }; class TWO { ONE onel; ONE one2; public: TWO(int m) : one2(m) { cout<<3; } }; int main() { TWO t(4); return 0; }运行时的输出结果是（）。
3
23
喵查答案：123
213

6 对于复制构造函数，正确的描述是（）。
喵查答案：

在C++语言中，如果不自定义类的复制构造函数，则每个类都有默认的复制构造函数
必须为每个类定义复制构造函数
如果要使用复制构造函数，则必须在类中先定义
当定义了类的构造函数时，如果要使用复制构造函数，则必须定义复制构造函数

7 假定有类AB，有相应的构造函数定义，能正确执行 “AB a(4),b(5), c[3] , *p[2]={&a,&b}；”语句，请问执行完此语句后共调用该类析构函数的次数为（）。
3
4
喵查答案：5
6

8 若Sample类中的一个成员函数说明如下：void set(Sample& a)，则Sample& a的含义是（）。

指向类Sample的名为a的指针
喵查答案：a是类Sample的对象引用，用来作函数Set()的形参
将a的地址赋给变量Set

变量Sample与a按位与的结果作为函数Set的参数

9 类的构造函数被自动调用执行的情况是在定义该类的（）。
成员函数时
数据成员时
喵查答案：对象时
友元函数时

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

11 下面类的定义，有（）处错误。class MyClass{ private: int i=0; public: void MyClass(); ~MyClass(int Value); };
1
2
喵查答案：3
4

12 在C++中，编译系统自动为一个类生成缺省构造函数的条件是（）。
该类没有定义任何有参构造函数
该类没有定义任何无参构造函数
喵查答案：该类没有定义任何构造函数
该类没有定义任何成员函数

13 有如下两个类定义：class AA{}; class BB { AA v1,*v2; BB v3; int *v4; };其中有一个成员变量的定义是错误的，这个变量是( )。
v1
v2
喵查答案：v3
v4

14 有如下程序：# include using namespace std; class Name { char name[20]; public: Name( ) { strcpy(name, ""); cout<<'?'; } Name(char *fname) { strcpy(name,fname); cout<<'?'; } }; int main( ) { Name names[3]={Name("张三"), Name("李四")}; return 0; }运行此程序输出符号?的个数是（）。
0
1
2
喵查答案：3

15 假定AA是一个类，“AA& abc();”是该类中一个成员函数的原型，若该函数存在对*this赋值的语句，当用x.abc()调用该成员函数后，x的值（）。
喵查答案：已经被改变
可能被改变
不变
不受函数调用的影响

16 设类A将其它类对象作为成员，则建立A类对象时，下列描述正确的是（）。
A类构造函数先执行
喵查答案：成员构造函数先执行
两者并行执行
不能确定

17 如果没有为一个类定义任何构造函数的情况下，下列描述正确的是（）。
喵查答案：编译器总是自动创建一个不带参数的构造函数
这个类没有构造函数
这个类不需要构造函数
该类不能通过编译

18 缺省析构函数的函数体是（）。
不存在
随机产生的
喵查答案：空的
无法确定的

19 类TM和类TN是两个独立的类，那么类TM中哪种形式的数据成员一定是不允许的?( )
TM * a;
TN & a;
喵查答案：TM a;
TN a;

20 有如下程序：#include using namespace std; class Test{ public: Test(){} ~Test(){cout<<'#';} }; int main(){ Test temp[2], *pTemp[2]; return 0; }执行这个程序输出星号（#）的个数为（）。
1
喵查答案：2
3
4

已知一个类Complex，有下述两行：Complex c; //A Complex c();//B

对于如下的类：

class Animal { float weight; int feet; public: Animal(float w,int f=4) {weight=w; feet=f;} };

定义其对象完全正确的一组语句是（）。
Animal a1(3.6, 8); Animal a2;
喵查答案：Animal a1(3.6, 8); Animal a2(67.9);
Animal a1(67.9); Animal a2;
Animal a1(3.6, 8); Animal a2();

23 C++如果某函数的返回值是个对象，则该函数被调用时，返回的对象（）。
喵查答案：是通过复制构造函数初始化的
是通过无参数的构造函数初始化的
用哪个构造函数初始化取决于函数中 return 语句是怎么写的
不需要初始化

24 下面表述错误的是（）。
喵查答案：this指针是字符指针
this指针是当前指针
this指针是隐含指针
this指针是特殊指针

25 有如下程序：#include using namespace std; class ONE { int c; public: ONE(): c(0) { cout<<1; } ONE(int n): c(n) { cout<<2; } }; class TWO { ONE onel; ONE one2; public: TWO(int m) : one2(m) { cout<<3; } }; int main() { TWO t(4); return 0; }运行时的输出结果是（）。
3
23
喵查答案：123
213

26 对于复制构造函数，正确的描述是（）。
喵查答案：

27 假定有类AB，有相应的构造函数定义，能正确执行 “AB a(4),b(5), c[3] , *p[2]={&a,&b}；”语句，请问执行完此语句后共调用该类析构函数的次数为（）。
3
4
喵查答案：5
6

28 若Sample类中的一个成员函数说明如下：void set(Sample& a)，则Sample& a的含义是（）。

指向类Sample的名为a的指针
喵查答案：a是类Sample的对象引用，用来作函数Set()的形参
将a的地址赋给变量Set

变量Sample与a按位与的结果作为函数Set的参数

29 类的构造函数被自动调用执行的情况是在定义该类的（）。
成员函数时
数据成员时
喵查答案：对象时
友元函数时

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

31 下面类的定义，有（）处错误。class MyClass{ private: int i=0; public: void MyClass(); ~MyClass(int Value); };
1
2
喵查答案：3
4

32 在C++中，编译系统自动为一个类生成缺省构造函数的条件是（）。
该类没有定义任何有参构造函数
该类没有定义任何无参构造函数
喵查答案：该类没有定义任何构造函数
该类没有定义任何成员函数

33 有如下两个类定义：class AA{}; class BB { AA v1,*v2; BB v3; int *v4; };其中有一个成员变量的定义是错误的，这个变量是( )。
v1
v2
喵查答案：v3
v4

34 有如下程序：# include using namespace std; class Name { char name[20]; public: Name( ) { strcpy(name, ""); cout<<'?'; } Name(char *fname) { strcpy(name,fname); cout<<'?'; } }; int main( ) { Name names[3]={Name("张三"), Name("李四")}; return 0; }运行此程序输出符号?的个数是（）。
0
1
2
喵查答案：3

35 假定AA是一个类，“AA& abc();”是该类中一个成员函数的原型，若该函数存在对*this赋值的语句，当用x.abc()调用该成员函数后，x的值（）。
喵查答案：已经被改变
可能被改变
不变
不受函数调用的影响

36 设类A将其它类对象作为成员，则建立A类对象时，下列描述正确的是（）。
A类构造函数先执行
喵查答案：成员构造函数先执行
两者并行执行
不能确定

37 如果没有为一个类定义任何构造函数的情况下，下列描述正确的是（）。
喵查答案：编译器总是自动创建一个不带参数的构造函数
这个类没有构造函数
这个类不需要构造函数
该类不能通过编译

38 缺省析构函数的函数体是（）。
不存在
随机产生的
喵查答案：空的
无法确定的

39 类TM和类TN是两个独立的类，那么类TM中哪种形式的数据成员一定是不允许的?( )
TM * a;
TN & a;
喵查答案：TM a;
TN a;

40 有如下程序：#include using namespace std; class Test{ public: Test(){} ~Test(){cout<<'#';} }; int main(){ Test temp[2], *pTemp[2]; return 0; }执行这个程序输出星号（#）的个数为（）。
1
喵查答案：2
3
4

41 #include class A { int x,y; public: A(int a,int b):x(a),y(b){} void set(int a,int b){ x=a; y=b; } void show(){ cout<<x<<”,”<<y<<endl; } }; void main() { A obj; obj.set(3,5); obj.show(); }对上述程序段，下述说法中正确的是（）。
喵查答案：在编译时报错，程序无法运行
编译无错，运行正常，输出3，5
编译无错，运行时报错
编译时报警告错，但运行正常，输出3，5

42 下列有关析构函数的描述中，正确的是（）。
析构函数的定义只能在类体内
析构函数可以有一个或多个参数
喵查答案：析构函数在撤消对象时，系统自动调用
析构函数可以重载

43 下列描述中，（）不是构造函数的特征。
构造函数可以重载
喵查答案：必须显式的为类定义一个构造函数
无需为构造函数指定返回值类型
构造函数在产生对象时由系统自动调用

44 复数类及对象的定义如下：class Complex { double real,image; public: Complex(double r=0, double i=0) {real=r; image=i; } Complex(Complex &c) {real=c.real; image=c.image; } };

Complex c1; //A Complex c2(3,5); //B Complex c3(c2); //C c2=c1; //D下述说法中正确的是（）。
C行和D行均调用了复制构造函数
喵查答案：C行调用了复制构造函数
B行调用了复制构造函数
A行调用了复制构造函数

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

46 有如下程序：#include using namespace std; class test{ private: int a; public: test(){cout<<"constructor"<<endl;} test(int t ):a(t) {cout<<a<<endl;} test(const test &_test) { a=_test.a; cout<<"copy constructor"<<endl; } ~test(){cout<<"destructor"<<endl;} }; int main() { test A(3); return 0; }运行时的输出结果是( )。
3
喵查答案：3 destructor
copy constructor
constructor

47 下列程序的运行结果为（）。#include int i=0; class A{ public: A(){i++;} }; void main() { A a; A b[3],*c; c=b; cout<<i<<endl; }
2
3
喵查答案：4
5

48 下列关于this指针的描述中，错误的是（）。
this指针是一个由系统自动生成的指针
this指针是指向对象的
this指针在用对象引用成员函数时系统创建的
喵查答案：this指针只能隐含使用，不能显式使用

设有定义：

class person { int num; char name[10]; public: void init(int n, char *m); //... };

person std[30];

则以下叙述不正确的是( )。
std是一个含有30个元素的对象数组
std数组中的每一个元素都是person类的对象
std数组中的每一个元素都有自己的私有变量num和name
喵查答案：std数组中的每一个元素都有各自的成员函数init

50 假定一个类AB 只含有一个整型数据成员a，用户为该类定义的带参构造函数可以为（）。
AB (){}
AB ():a(0){}
喵查答案：AB (int aa=0){a=aa;}
AB (int aa){}

51 假定一个类AB 只含有一个整型数据成员a，当用户不定义任何构造函数时，系统为该类定义的无参构造函数为（）。
AB (){a=0;}
AB (int aa=0):a(aa){}
AB (int aa):a(aa){}
喵查答案：AB (){}

52 假定一个类的构造函数为 “B(int ax, int bx): a(ax), b(bx) {}”，执行 “B x(1,2),y(3,4);x=y;”语句序列后x.a的值为。
1
2
喵查答案：3
4

53 假定AB 为一个类，则（）为该类的复制构造函数的原型说明。
AB (AB x);
喵查答案：AB (AB &x);
void AB (AB &x);
AB (int x);

54 假定一个类的构造函数为 “A(int aa=1, int bb=0) {a=aa; b=bb;}”，则执行 “A x(4);”语句后，x.a和x.b的值分别为（）。
1和0
1和4
4和1
喵查答案：4和0

55 假定一个类的构造函数为 “A(int aa, int bb) {a=aa; b=aa*bb;}”，则执行 “A x(4,5);”语句后，x.a和x.b的值分别为（）。
4和5
5和4
喵查答案：4和20
20和5

56 假定AB 为一个类，则执行“AB r1=r2;”语句时将自动调用该类的（）。
无参构造函数
带参构造函数
赋值重载函数
喵查答案：拷贝构造函数

57 假定AB 为一个类，则执行“AB x(a,5);”语句时将自动调用该类的（）。
喵查答案：带参构造函数
无参构造函数
拷贝构造函数
赋值重载函数

58 假定AB 为一个类，则执行“AB x;”语句时将自动调用该类的（）。
带参构造函数
喵查答案：无参构造函数
拷贝构造函数
赋值重载函数

59 一个类的析构函数通常被定义为该类的（）成员。
私有
保护
喵查答案：公有
友元

60 一个类的构造函数通常被定义为该类的（）成员。
喵查答案：公有
保护
私有
友元

61 在C++中，当一个对象被创建后，它的每一个成员函数都含有一个系统自动生成的隐含的指针，称之为（）指针。
对象
派生
基类
喵查答案：this

62 复制构造函数的作用是（）。
进行数据类型的转换
用对象调用成员函数
喵查答案：用对象初始化对象
用一般类型的数据初始化对象

63 下列关于对象数组的描述中，（）是错误的。
对象数组的下标是从0开始的
对象数组的数组名是一个指针常量
对象数组的每个元素是同一个类的对象
喵查答案：对象数组只能赋初值，而不能被赋值

64 一个类的析构函数是在（）时被自动调用。
使用该类对象前
使用该类对象后
喵查答案：该类对象撤消
定义该类对象

65 对于复制构造函数point::point(point& p)，下列说明正确的是（）。
该函数只能访问p的私有成员
该函数不能访问p的公有成员
喵查答案：该函数可以访问p的私有和公有成员
该函数不能访问p的成员

66 类的析构函数的作用是（　　）。
一般成员函数的初始化
类的初始化
对象的初始化
喵查答案：删除类创建的对象

67 类的构造函数的作用是（　　）。
一般成员函数
类的初始化
喵查答案：对象的初始化
删除对象

68 类AB的缺省构造函数和析构函数是（　　）。
喵查答案：AB( )和~AB( )
AB(int)和~AB( )
AB( )和~AB(delete )
AB( )和int~AB( )

69 复制构造函数具有的下列特点中，（　　）是错误的。

如果一个类中没有定义复制构造函数时，系统将自动生成一个默认的
复制构造函数只有一个参数，并且是该类对象的引用
复制构造函数是一种成员函数
喵查答案：

复制构造函数的名字不能用类名

70 假定Mylass为一个类，则该类的复制构造函数的声明语句为（）。
MyClass&(MyClass x)；
MyClass(MyClass x)；
喵查答案：MyClass(MyClass &x)；
MyClass(MyClass *x)；

71 假定AB为一个类，则执行 “AB r1=r2;” 语句时将自动调用该类的（　　）。
无参构造函数
带参构造函数
赋值重载函数
喵查答案：复制构造函数

72 假定AB为一个类，则( )为该类的复制构造函数的原型说明。
AB(AB x);
AB(int x);
喵查答案：AB(AB& x);
void AB(AB& x);

73 假定A 为一个类,则执行A x;语句时将自动调用该类的( ) 。
有参构造函数
喵查答案：无参构造函数
拷贝构造函数
赋值构造函数

74 关于下面程度段说法正确的是( ).class X { private: int n; punblic: X(X&); } X::X(X&x){n=x.n}

X obj1,obj2; obj2(obj1);
喵查答案：

语句obj2（obj1）；的功能是用对象obj1初始化具有相同类类型的对象obj2

语句obj2（obj1）；的功能是用对象obj2初始化具有相同类类型的对象obj1
X(X&x)也可以不使用引用参数而仍然是拷贝构造函数
X(X&x)不能访问对象的私有成员

75 关于对象成员的构造函数的调用顺序，说法正确的是( )。
与他们在成员初始化列表中给出的顺序相同
与折构函数的调用顺序相同
喵查答案：与他们在类中说明顺序相同
其他说法都不对

76 下列函数中，（）不能重载。
成员函数
非成员函数
喵查答案：析构函数
构造函数

77 对类对象成员的初始化是通过构造函数中给出的（）实现的。
函数体
喵查答案：初始化表
参数表
初始化表或函数体

78 假定AB 为一个类，则执行“AB a,b(2),c[3],*p=&a;”语句时共调用该类无参构造函数的次数为（）。
5
6
3
喵查答案：4

79 假定AB 为一个类，则执行“AB a,b(3),*p;”语句时共调用该类构造函数的次数为（）。
喵查答案：2
3
4
5

80 假定AB 为一个类，则执行“AB a(2),b[3],*p[4];”语句时共调用该类构造函数的次数为（）。
3
喵查答案：4
5
9

81 假定一个类对象数组为A[n]，当离开它定义的作用域时，系统自动调用该类析构函数的次数为（）。
0
1
喵查答案：n
n-1

82 下列关于析构函数的描述中，错误的是（）。
喵查答案：析构函数的函数体都为空
析构函数是用来释放对象的
析构函数是系统自动调用的
析构函数是不能重载的

83 下面的哪一个构造函数头格式不正确（　　）。　　
AA(int a,int b)　
AA(int a,int b＝0)
AA(int a＝0,int b＝0)
喵查答案： AA(int a＝0,int b)

84 下列关于构造函数的描述中，错误的是（）。
构造函数可以设置默认的参数
构造函数在定义类对象时自动执行
构造函数可以是内联函数
喵查答案：构造函数不可以重载

85 下列( )不是构造函数的特征。
构造函数的函数名与类名相同
构造函数可以重载
构造函数可以设置默认参数
喵查答案：构造函数必须指定类型说明

86 （）是析构函数的特征。
析构函数可以有一个或多个参数
析构函数定义只能在类体内
析构函数名与类名不同
喵查答案：一个类中只能定义一个析构函数

87 假定一个类的构造函数为B(int x,int y){a=x–;b=a*y–;},则执行B x(3,5); 语句后，x.a和x.b的值分别为（）。
3和5
5和3
喵查答案：3和15
20和5

88 下列对类的构造函数和析构函数的叙述，正确的是（）。
喵查答案：构造函数可以重载，析构函数不能重载
构造函数不能重载，析构函数可以重载
构造函数可以重载，析构函数也可以重载
构造函数不能重载，析构函数也不能重载

89 执行下列说明语句，其调用构造函数的次数为（）。A a[5]，*p[2];其中，A是一个类名
喵查答案：5
6
7
8

90 在下列函数原型中，可以作为类AA构造函数的是（）。
void AA(int);
int AA();
AA(int)const;
喵查答案：AA(int);

91 已知example是已定义的类,则程序结束前,共存在( )个对象。#include class example { int y; public: example(int a){y=a;cout<<"constructor"<<endl;} void print(){cout<<"y="<<y<<endl;} }; void main() { example x(5); example arr[2]={1,2}; x=10; x.print(); }
2
喵查答案：3
4
5

92 已知AA是一个类，则执行语句AA a;后（）。
喵查答案：自动调用无参构造函数
自动调用有参构造函数
自动调用拷贝构造函数
产生一个对象a,但不调用任何函数

93 已知X类.则当程序执行到语句X array[3];时，调用了( )次构造函数。
0
1
2
喵查答案：3

94 一个类中一个无参数构造函数和一个全部都是默认参数的构造函数共存是否存在二义性（）。
喵查答案：存在
不存在
无法确定
视构造函数的参数来确定

95 定义析构函数时，正确的是（　　）。
其名与类名完全相同　
喵查答案：无形参，也没有返回值
返回类型是 void 类型
函数体中必须有 delete 语句

96 一个类拥有多个构造函数，则这些构造函数之间为（）。
喵查答案：重载关系
重复关系
拷贝关系
无关系

97 一个类可包含析构函数的个数是（）。
多个
喵查答案：1个
至少一个
0个或多个

98 形如X::X(X&)的构造函数称为( )。
拷贝函数
复制函数
初始化函数
喵查答案：复制构造函数

99 下面有关构造函数的描述中，正确的是（）。
构造函数可以带有返回值
喵查答案：构造函数的名字与类名完全相同
构造函数必须带有参数
构造函数必须定义，不能缺省

100 下面说法中正确的是（）。
一个类只能定义一个构造函数，但可以定义多个析构函数
喵查答案：一个类只能定义一个析构函数，但可以定义多个构造函数
构造函数与析构函数同名，只是名字前加了一个求反符号（~）
构造函数可以指定返回类型，而析构函数不能指定任何返回类型，即使是void类型也不可以

101 下面（　　）项是对构造函数和析构函数的正确定义。
void X::X(), void X::~X()
喵查答案：X::X(参数), X::~X()
X::X(参数), X::~X(参数)
void X::X(参数), void X::~X(参数)

102 下列关于子对象(内嵌对象成员)的描述中，错误的是（）。
子对象不可以是自身类的对象
子对象是另一个类的对象
子对象的初始化要包含在构造函数中
喵查答案：一个类中只能有一个子对象

103 下列关于析构函数描述正确的是( )。
可以重载
函数体中必须有delete语句
返回类型必须是void类型
喵查答案：不能指定返回类型

104 指向对象的常指针的地址值是可以改变的。
正确
喵查答案：错误

105 在程序中可以显式调用构造函数。
喵查答案：正确
错误

106 一个类中只能定义一个析构函数。
喵查答案：正确
错误

107 析构函数可以有形参。
正确
喵查答案：错误

108 析构函数不指定参数，而构造函数可以指定参数。
喵查答案：正确
错误

109 类的析构函数的作用是对象的初始化。
正确
喵查答案：错误

110 假定AB为一个类，则执行“AB a[10];”语句时，系统自动调用该类的构造函数的次数为1次。
正确
喵查答案：错误

111 构造函数是一个其名与类名相同的特殊的成员函数。
喵查答案：正确
错误

112 构造函数没有函数返回类型。
喵查答案：正确
错误

113 构造函数可以设置默认参数。
喵查答案：正确
错误

114 构造函数和析构函数都是系统自动调用的成员函数。
喵查答案：正确
错误

115 构造函数和析构函数都可以重载。
正确
喵查答案：错误

116 构造函数和析构函数都可以重载，因为它们都是成员函数。
正确
喵查答案：错误

117 构造函数的功能是对对象进行初始化。
喵查答案：正确
错误

118 给对象数组元素赋值时都要创建临时对象。
正确
喵查答案：错误

119 对象指针数组可以使用不同类的对象的地址值进行初始化。
正确
喵查答案：错误

120 构造函数和析构函数都可以带参数。
正确
喵查答案：错误

121 一个类的构造函数中可以不包含对其内嵌对象的初始化。
正确
喵查答案：错误

122 类中的成员数据可以是另一个类的对象。
喵查答案：正确
错误

123 如果程序中未声明析构函数，编译器将自动产生一个默认的析构函数。
喵查答案：正确
错误

124 如果程序中未声明构造函数，则系统自动产生出一个默认形式的构造函数。
喵查答案：正确
错误

125 如果在类声明中没有定义复制构造函数，就不能用一个对象去初始化另一个对象。
正确
喵查答案：错误

126 复制构造函数的参数可以是某类的对象名。
正确
喵查答案：错误

127 通常的复制构造函数的参数是某个对象的指针名。
正确
喵查答案：错误

128 一维对象指针数组的每个元素应该是某个类的对象的地址值。
喵查答案：正确
错误

129 指向对象数组的指针不一定必须指向数组的首元素。
喵查答案：正确
错误

130 对象数组的元素可以是不同类的对象。
正确
喵查答案：错误

131 构造函数和析构函数都不能重载。
正确
喵查答案：错误

132 自身类对象可作该类的子对象。
正确
喵查答案：错误

133 子对象的初始化要在构造函数的成员初始化列表中进行。
喵查答案：正确
错误

134 对象指针可用同类对象的地址值给它赋值。
喵查答案：正确
错误

135 对象指针成员表示与对象引用相同。
正确
喵查答案：错误

136 对象引用可以用一个同类对象的地址值对它赋值。
正确
喵查答案：错误

137 定义或说明对象时，系统会自动调用构造函数为创建的对象初始化。如果类中没有定义任何构造函数时，就无法给定义的对象初始化。
正确
喵查答案：错误

138 定义对象指针时也要调用构造函数。
正确
喵查答案：错误

139 创建对象时系统自动调用相应的构造函数为对象初始化，没有相应的构造函数时，系统会自动生成。
喵查答案：正确
错误

140 this指针是系统生成的指向当前被某个成员函数操作对象的指针。
喵查答案：正确
错误

141 重载函数可以带默认值参数，但要注意二义性。
喵查答案：正确
错误

1 对类中引用成员的初始化是通过构造函数中给出的（）实现的。
函数体
参数表
喵查答案：初始化表
初始化表或函数体

2 假定AB为一个类，px为指向该类的一个含有n个对象的动态数组的指针，则执行“delete []px;”语句时共调用该类析构函数的次数为（）。
0
1
喵查答案：n
n+1

3 假定AA是一个类，“AA* abc()const;”是该类中一个成员函数的原型，若该函数返回this值，当用x.abc()调用该成员函数后，x的值（）。
已经被改变
可能被改变
喵查答案：不变
受到函数调用的影响

4 假定指针变量p定义为“int *p=new int(100);”，要释放p所指向的动态内存，应使用语句（）。
喵查答案：delete p;
delete *p;
delete &p;
delete []p;

5 要使语句“p=new int[10][20];”能够正常执行，p应被事先定义为（）。
int *p;
int **p;
int *p[20];
喵查答案：int(*p)[20];

6 下面对于常数据成员的描述正确的是( )。
常数据成员可以不初始化，并且不能更新。
喵查答案：常数据成员必须初始化，并且不能更新。
常数据成员可以不初始化，并且可以被更新
常数据成员必须初始化，并且可以更新。

7 有如下程序：#include #include class XCF { int a; public: XCF (int aa=0) : a(aa) { cout<<"1"; } XCF(XCF & x) { a=x.a; cout<<"2"; } ~XCF( ) { cout<<a; } int Geta( ) { return a; } }; void main( ) { XCF d1(5),d2(d1); XCF *pd=new XCF(8); cout<Geta( ); delete pd; }运行时的输出结果是（）。
1215588
喵查答案：1218855
12185
128512

8 有如下类定义：class A { char *a; public: A( ) : a(0){} A(char *aa) { //把aa所指字符串拷贝到a所指向的存储空间 a=?; strcpy(a,aa); } ~A( ) (delete []a;} };?处应填写的表达式是( )。
喵查答案：

new char[strlen(aa)+1]
char[strlen(aa)+1]
char[strlen(aa)]
new char[sizeof(aa)-1]

9 已知类MyClass 声明如下： class MyClass { int n; public: MyClass(int k) : n(k) {} int getValue()const { return n; } };在下列数组定义中正确的是（）。

MyClass x[2];
MyClass x[2]={new MyClass(1), new MyClass(2)};
喵查答案：MyClass *x[2];
MyClass *x[2]={MyClass(1), MyClass(2)};

10 对类中常量成员的初始化是通过构造函数中给出的( )实现的。
函数体
参数表
喵查答案：初始化表
初始化表或函数体

11 当类中的一个整型指针成员指向一块具有n*sizeof(int)大小的存储空间时，它最多能够存储（）个整数。
喵查答案：n
n+1
n-1
1

12 当类中一个字符指针成员指向具有n个字节的存储空间时，它所能存储字符串的最大长度为（）。
n
n+1
喵查答案：n-1
n-2

13 执行如下程序后的输出结果是（）。#include class test{ static int count; public: test(){count++;} ~test(){count--;} static int getCount(){return count;} }； int test::count=0; int main() { test *p=new test; test *q=new test; delete p; cout<<"count="<<test::getCount()<<endl; return 0; }
count=0
喵查答案：count=1
count=2
count=3

14 关于const关键字说法错误的是（）。
const关键字可以修饰对象和成员函数
const对象不能被修改
const成员函数不能修改类数据成员
喵查答案：const可以用于说明类

15 删除动态对象，需要使用操作符（）。
new
喵查答案：delete
.
*

16 创建动态对象，需要使用操作符（）。
喵查答案：new
delete
.
*

17 在以下new和delete运算符使用中，错误的是( )。
char *p=new char[10]; delete[]p;
char *p=new char[5]; delete []p; p=new char[10]; delete []p;
char *p=new char; delete p;
喵查答案：char *p=new int[10]; delete p;

18 下面表述中不正确的是（）。
C++中动态内存分配用new建立动态对象，用delete删除动态对象
类和对象的关系就类似数据类型和变量的关系
构造函数是和类同名的成员函数
喵查答案：如果#if后的常量表达值为真，则不编译这部分，否则就编译该部分

19 有如下程序：#include #include using namespace std; class MyClass{ 　public: 　　 MyClass(){cout<<'A';} 　　 MyClass(char c ){cout<<c;} 　　 ~MyClass(){cout<<'B';} }; void main() { 　　 MyClass p1,*p2; 　　 p2=new MyClass('X’); 　　 delete p2; }　执行这个程序，将显示输出（）。
ABX
ABXB
AXB
喵查答案：AXBB

20 有如下程序：#include using namespace std; class Point{ public: static int number; public: Point(){number++;} ~Point(){number--;} }; int Point::number=0; void main(){ Point *ptr; Point A,B; Point* ptr_point=new Point[3]; ptr=ptr_point; Point C; cout<<Point::number<<endl; delete[]ptr; }运行时输出的结果是（）。
3
4
喵查答案：6
7

21 对类中引用成员的初始化是通过构造函数中给出的（）实现的。
函数体
参数表
喵查答案：初始化表
初始化表或函数体

22 假定AB为一个类，px为指向该类的一个含有n个对象的动态数组的指针，则执行“delete []px;”语句时共调用该类析构函数的次数为（）。
0
1
喵查答案：n
n+1

23 假定AA是一个类，“AA* abc()const;”是该类中一个成员函数的原型，若该函数返回this值，当用x.abc()调用该成员函数后，x的值（）。
已经被改变
可能被改变
喵查答案：不变
受到函数调用的影响

24 假定指针变量p定义为“int *p=new int(100);”，要释放p所指向的动态内存，应使用语句（）。
喵查答案：delete p;
delete *p;
delete &p;
delete []p;

25 要使语句“p=new int[10][20];”能够正常执行，p应被事先定义为（）。
int *p;
int **p;
int *p[20];
喵查答案：int(*p)[20];

26 下面对于常数据成员的描述正确的是( )。
常数据成员可以不初始化，并且不能更新。
喵查答案：常数据成员必须初始化，并且不能更新。
常数据成员可以不初始化，并且可以被更新
常数据成员必须初始化，并且可以更新。

27 有如下程序：#include #include class XCF { int a; public: XCF (int aa=0) : a(aa) { cout<<"1"; } XCF(XCF & x) { a=x.a; cout<<"2"; } ~XCF( ) { cout<<a; } int Geta( ) { return a; } }; void main( ) { XCF d1(5),d2(d1); XCF *pd=new XCF(8); cout<Geta( ); delete pd; }运行时的输出结果是（）。
1215588
喵查答案：1218855
12185
128512

28 有如下类定义：class A { char *a; public: A( ) : a(0){} A(char *aa) { //把aa所指字符串拷贝到a所指向的存储空间 a=?; strcpy(a,aa); } ~A( ) (delete []a;} };?处应填写的表达式是( )。
喵查答案：

new char[strlen(aa)+1]
char[strlen(aa)+1]
char[strlen(aa)]
new char[sizeof(aa)-1]

29 已知类MyClass 声明如下： class MyClass { int n; public: MyClass(int k) : n(k) {} int getValue()const { return n; } };在下列数组定义中正确的是（）。

MyClass x[2];
MyClass x[2]={new MyClass(1), new MyClass(2)};
喵查答案：MyClass *x[2];
MyClass *x[2]={MyClass(1), MyClass(2)};

30 对类中常量成员的初始化是通过构造函数中给出的( )实现的。
函数体
参数表
喵查答案：初始化表
初始化表或函数体

31 当类中的一个整型指针成员指向一块具有n*sizeof(int)大小的存储空间时，它最多能够存储（）个整数。
喵查答案：n
n+1
n-1
1

32 当类中一个字符指针成员指向具有n个字节的存储空间时，它所能存储字符串的最大长度为（）。
n
n+1
喵查答案：n-1
n-2

33 执行如下程序后的输出结果是（）。#include class test{ static int count; public: test(){count++;} ~test(){count--;} static int getCount(){return count;} }； int test::count=0; int main() { test *p=new test; test *q=new test; delete p; cout<<"count="<<test::getCount()<<endl; return 0; }
count=0
喵查答案：count=1
count=2
count=3

34 关于const关键字说法错误的是（）。
const关键字可以修饰对象和成员函数
const对象不能被修改
const成员函数不能修改类数据成员
喵查答案：const可以用于说明类

35 删除动态对象，需要使用操作符（）。
new
喵查答案：delete
.
*

36 创建动态对象，需要使用操作符（）。
喵查答案：new
delete
.
*

37 在以下new和delete运算符使用中，错误的是( )。
char *p=new char[10]; delete[]p;
char *p=new char[5]; delete []p; p=new char[10]; delete []p;
char *p=new char; delete p;
喵查答案：char *p=new int[10]; delete p;

38 下面表述中不正确的是（）。
C++中动态内存分配用new建立动态对象，用delete删除动态对象
类和对象的关系就类似数据类型和变量的关系
构造函数是和类同名的成员函数
喵查答案：如果#if后的常量表达值为真，则不编译这部分，否则就编译该部分

39 有如下程序：#include #include using namespace std; class MyClass{ 　public: 　　 MyClass(){cout<<'A';} 　　 MyClass(char c ){cout<<c;} 　　 ~MyClass(){cout<<'B';} }; void main() { 　　 MyClass p1,*p2; 　　 p2=new MyClass('X’); 　　 delete p2; }　执行这个程序，将显示输出（）。
ABX
ABXB
AXB
喵查答案：AXBB

40 有如下程序：#include using namespace std; class Point{ public: static int number; public: Point(){number++;} ~Point(){number--;} }; int Point::number=0; void main(){ Point *ptr; Point A,B; Point* ptr_point=new Point[3]; ptr=ptr_point; Point C; cout<<Point::number<<endl; delete[]ptr; }运行时输出的结果是（）。
3
4
喵查答案：6
7

41 下面各个程序中哪些是不正确的是（）。
喵查答案：

int i;

int * const pi = NULL ;

pi = &i;

const int i =10;

const int * pi = &i;

const int i = 10;

int j = 0;

const int * pi = &i;

pi = &j;

int i =10;

const int * pi = &i;

42 有如下程序：#include using namespace std; class AA{ int n; public: AA(int k):n(k){ } int get( ){ return n;} int get( )const{ return n+1;} }; int main( ) { AA a(5); const AA b(6); cout<<a.get( )<<b.get( ); return 0; }执行后的输出结果是（）。

55
喵查答案：57
75
77

43 有如下程序：#include using namespace std; class Test { public: Test( ) { n+=2; } ~Test( ) { n-=3; } static int getNum( ) { return n; } private: static int n; }; int Test::n = 1; int main( ) { Test* p = new Test; delete p; cout << "n=" << Test::getNum( ) << endl; return 0; }执行后的输出结果是（）。
喵查答案：n=0
n=1
n=2
n=3

44 类MyClass的定义如下：class MyClass { public: MyClass() { value = 0;} SetVariable(int i) { value = i; } private: int value; }; 则对下列语句序列正确的描述是（）。 MyClass *p，my； p=&my；

语句p=&my；是把对象my赋值给指针变量p
语句MyClass *p，my；会调用两次类MyClass的构造函数
对语句 *p.SetVariable(5)的调用是正确的
喵查答案：语句p->SetVariable(5)与语句my.SetVariable(5)等价

45 关于new运算符的错误的描述是（）。
喵查答案：使用运算符new创建对象数组时必须定义初始值
使用运算符new创建对象时，会调用类的构造函数
运算符new可以用来动态创建对象和对象数组
使用new运算符创建的对象可以使用运算符delete删除

46 对下列语句正确的描述是（）。 const int *x； //① int *const x； //②

语句①的含义是指针变量x不能更改
语句②的含义是指针变量x所指向的值不能更改
喵查答案：语句②的含义是指针变量x不能更改
语句①和②是相同含义的不同定义方式

47 关于delete运算符的下列描述中，（）是错误的。
它必须用于new返回的指针
它也适用于空指针
喵查答案：对一个指针可以使用多次该运算符
指针名前只用一对方括号符，不管所删除数组的维数

48 关于new运算符的下列描述中，（）是错误的。
它可以用来动态创建对象和对象数组
使用它创建的对象或对象数组可以使用运算符delete删除
使用它创建对象时要调用构造函数
喵查答案：使用它创建对象数组时必须指定初始值

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

50 对于动态分配内存空间描述正确的是（　　）。
使用new运算符分配的内存空间的长度必需是常量
delete运算符可以释放动态的存储空间和静态的存储空间
由new分配的内存空间是不连续的
喵查答案：delete运算符只能释放由new分配的动态存储空间

51 对于常成员函数，下列描述正确的是（）。
常成员函数只能修改常数据成员
常成员函数只能修改一般数据成员
喵查答案：常成员函数不能修改任何数据成员
常成员函数只能通过常对象调用

52 运算符delete删除一个动态对象时（）。
首先为该动态对象调用构造函数,在释放其占用的内存
首先释放该动态对象占用的内存,在为其调用构造函数
喵查答案：首先为该动态对象调用析构函数,在释放其占用的内存
首先释放动态对象占用的内存,在为其调用析构函数

53 对使用关键字new所开辟的动态存储空间，释放时必须使用（）。
free
create
喵查答案：delete
realse

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

55 下列关于指针概念的描述中，错误的是（）。
指针中存放的是某变量或对象的地址值
喵查答案：指针的类型是它所存放的数值的类型
指针是变量，它也具有一个内存地址值
指针的值（非常量指针）是可以改变的

56 下列关于运算符new的描述中，错误的是（）。
它可以创建对象或变量
它可以创建对象数组或一般类型数组
用它创建对象或对象数组时要调用相应的构造函数
喵查答案：用它创建的对象可以不用delete运算符释放

57 下列关于运算符delete的描述中，错误的是（）。
使用该运算符可以释放用new运算符创建的对象或对象数组
喵查答案：使用该运算符可以释放所有对象
使用delete运算符时会自动调用析构函数
用它释放对象数组时，它作用的指针名前要加下标运算符[ ]

58 下列关于常成员的描述中，错误的是（）。
常成员是用关键字const说明的
常数据成员和常成员函数是常成员
喵查答案：常数据成员的初始化是在类体内定义它时进行的
常数据成员的值是不可以改变的

59 关于new运算符的下列描述中，（）是错误的。
它可以用来动态创建对象和对象数组
使用它创建的对象或对象数组可以使用运算符delete删除
使用它创建对象时会自动调用构造函数
喵查答案：使用它创建对象数组时必须指定初始值

60 有如下程序：执行后的输出结果应该是（）。#include class cla{ static int n; public: cla(){n++;} ~cla(){n--;} static int get_n(){return n;} }; int cla::n=0; int main() { cla *p=new cla; delete p; cout<<"n="<<cla::get_n()<<endl; return 0; }
喵查答案：n=0
n=1
n=3
n=4

61 下列程序的执行结果是（）。#include #include class ABC { char *str; int max_len; public: ABC(int i, char *s); ~ABC(); }; ABC::ABC(int i, char *s) { max_len=i+1; str=new char[max_len]; strcpy(str, s); } ABC::~ABC() { cout<<str; delete str; } void main() { char *ss="Hello, C++ !"; ABC sd(strlen(ss), ss); cout<<"Main end."; }
Main end.
Hello, C++ !
喵查答案：Main end.Hello, C++ !
Hello, C++ !Main end.

62 使用delete[]删除对象数组时，描述正确的是（）。
喵查答案：数组中各元素都调用析构函数
数组中各元素都调用构造函数
不调用析构函数
只有首元素调用析构函数

63 类MyClass的定义如下：class MyClass { public： MyClass(){} MyClass(int i){value=new int(i);} int * value； }； 若要对value赋值，则下面语句正确的是（）。

MyClass my；my.value=10；

MyClass my；*my.value=10；
MyClass my；my.*value=10；
喵查答案：MyClass my(10)；

64 可以被对象之外访问的成员是（　　）。
私有成员函数
喵查答案：公有成员函数
常量成员函数
所有成员函数

65 关于类中数据成员的生存期的说法正确的是（）。
与对象的生存期无关
比对象的生存期长
比对象的生存期短
喵查答案：由对象的生存期决定

66 关于成员函数特征的描述中，不正确的是（　　）。
成员函数的第一个参数有一个隐含的this 指针
成员函数可以是常成员函数，逻辑上不改变对象的状态
喵查答案：成员函数不可以是静态的，只有数据成员可以是静态的
作用在常对象的非常成员函数在编译中会出现错误或警告

67 关于常成员的描述中，错误的是（　　）。
常成员包含常数据成员和常成员函数两种
喵查答案：常数据成员必须是公有的
常数据成员要使用构造函数成员初始化列表进行初始化
常对象只能调用它的常成员函数，不能调用其它的成员函数

68 下面程序的输出结果是（　　）。#include class example { int a; public: example(int b){a=b++;} void print(){a=a+1;cout<< a<<" ";} void print()const{cout<<a ; } }; void main() { example x(3); const example y(2); x.print(); y.print(); }
2 2
4 3
喵查答案：4 2
3 2

69 用new 运算符创建一个含10个元素的一维整型数组的正确语句是（）。
int *p=new a[10];
int *p=new float[10];
喵查答案：int *p=new int [10];
int *p=new int [10]={1,2,3,4,5};

70 假定AB 为一个类，px为指向该类的一个含有n个对象的动态数组的指针，则执行“delete []px;”语句时共调用该类析构函数的次数为（）。
0
1
喵查答案：n
n+1

71 假定AB 为一个类，则执行“AB *p=new AB (1,2);”语句时共调用该类构造函数的次数为（）。
0
喵查答案：1
2
3

72 设px是指向一个类对象的指针变量，则执行“delete px;”语句时，将自动调用该类的（）。
无参构造函数
带参构造函数
喵查答案：析构函数
拷贝构造函数

73 假定AB 为一个类，则执行“AB *px=new AB [n];”语句时将（）。
喵查答案：动态分配一个数组
动态分配一个对象
静态分配一个数组
静态分配一个对象

74 若需要使类中的一个指针成员指向一块动态存储空间，则通常在（）函数中完成。
析构
喵查答案：构造
任一成员
友元

75 对于下面定义的类A在函数f()中将对象成员n的值修改为60的语句应该是（）。class A { public: A(int x){n=x;} void SetNum(int n1){n=n1;} private： int n; }; int f() { A *ptr=new A(60); }

A(60)
SetNum(60)
喵查答案：Ptr->SetNum(60)

Ptr->n=60

76 若对象有动态分配的存储空间，就必须定义复制构造函数。
喵查答案：正确
错误

77 如果类的构造函数中有动态申请的存储空间，在析构函数中应释放该空间。
喵查答案：正确
错误

78 返回值为本类对象的引用，不需初始化内存临时对象，返回值是对象自身，即*this。
喵查答案：正确
错误

79 返回对象的引用时，不能用局部对象做为返回值。
喵查答案：正确
错误

80 成员函数定义返回的是对象的引用，最后可以返回函数内部的局部对象。
正确
喵查答案：错误

81 常引用做形参，在函数中不能更新所引用的对象。
喵查答案：正确
错误

82 用new动态申请的内存空间，必须用delete来释放。
喵查答案：正确
错误

83 const对象不能随意被修改，但const成员函数可以修改const对象。
正确
喵查答案：错误

84 定义指向常对象的指针后，指针所指向的对象是可以改变的。
正确
喵查答案：错误

85 只有常成员函数才可以操作常对象。
喵查答案：正确
错误

86 在C++中，动态分配内存是通过new来实现的。
喵查答案：正确
错误

87 运算符new可以创建变量或对象，也可以创建数组。
喵查答案：正确
错误

88 使用new运算符创建数组时，可以为该数组指定初始值。
正确
喵查答案：错误

89 使用new运算符创建的对象数组其元素都具有默认值。
正确
喵查答案：错误

90 任何对象都可以使用delete运算符来释放。
正确
喵查答案：错误

91 常数据成员在常成员函数中的值是不允许改变的，而在非常成员函数中是允许改变的。
正确
喵查答案：错误

92 常类型指针有两种，一种是指针的地址值是常量，另一种是指针所指向的变量或对象是常量。
喵查答案：正确
错误

93 常对象只能调用常成员函数。
喵查答案：正确
错误

94 常对象需要引用常成员函数，而不能引用非常成员函数。
喵查答案：正确
错误

95 常对象可以调用任意成员函数。
正确
喵查答案：错误

96 常对象的数据成员都是常数据成员。
正确
喵查答案：错误

97 常成员指的是类体内使用const关键字说明的常数据成员和常成员函数。
喵查答案：正确
错误

1 下面关于友元的描述中，错误的是（）。
友元函数可以访问该类的私有数据成员
一个类的友元类中的成员函数都是这个类的友元函数
友元可以提高程序的运行效率
喵查答案：类与类之间的友元关系可以传递

2 下面关于静态成员函数的叙述中错误的是（）。
静态成员函数可以有返回值
喵查答案：this指针可以指向静态成员函数
静态成员函数可以具有指针参数
静态成员函数可有返回值类型

3 下面对于友元函数描述正确的是（　　）。
友元函数的实现必须在类的内部定义
友元函数是类的成员函数
喵查答案：友元函数从表面上看破坏了类的封装性和隐藏性
友元函数不能访问类的私有成员

4 下面对静态数据成员的描述中，正确的是（　　）。
静态数据成员可以在类体内进行初始化
静态数据成员不可以被类的对象调用
静态数据成员不能受private控制符的作用
喵查答案：静态数据成员可以直接用类名调用

5 下列关于友元函数的描述中，错误的是（）。
友元函数不是成员函数
喵查答案：友元函数只可访问类的私有成员
普通函数作为友元函数时，其调用方法同一般函数
友元函数可以是另一类中的成员函数

6 下列关于友元的描述错误的是（）。
喵查答案：成员函数不可作友元
类可以作友元
普通函数可以作友元
静态函数可以作友元

7 下列关于静态数据成员的说法，不正确的是（）。
类中定义的公用静态数据成员，可以通过类的对象来访问
类中定义的所有静态数据成员，都必须在类外初始化
喵查答案：静态数据成员不是所有对象所共用的
普通的成员函数可以直接访问类中的静态数据成员

8 下列关于静态成员的描述中，错误的是（）。
静态成员都是使用static来说明的
静态成员是属于类的，不是属于某个对象的
喵查答案：静态成员只可以用类名加作用域运算符来引用，不可用对象引用
静态数据成员的初始化是在类体外进行的

9 下列访问公有静态成员的方式，错误的是（）。
类名:: 静态成员名
对象名.静态成员名
对象指针->静态成员名
喵查答案：对象指针.静态成员名

10 （）只能访问静态成员变量。
喵查答案：静态成员函数
虚函数
构造函数
析构函数

11 （）的功能是对对象进行初始化。
析构函数
数据成员
喵查答案：构造函数
静态数据成员

12 类的静态成员的访问控制（）。
只允许被定义为private
只允许被定义为private或protected
只允许被定义为public
喵查答案：可允许被定义为private、protected或public

13 一个类的静态数据成员所表示属性（）。
是类的或对象的属性
只是对象的属性
喵查答案：只是类的属性
类和友元的属性

14 非静态成员函数都会有一个隐含指针，它是（）。
self指针
喵查答案：this指针
current指针
one指针

15 对于友元描述正确的是（）。
友元是本类的成员函数
喵查答案：友元不是本类的成员函数
友元不是函数
友元不能访问本类私有成员

16 若类X是类Y的友元类，则下列访问关系中（）是正确的。
类X的成员不能访问类Y的私有成员
喵查答案：类X的成员可以访问类Y的私有成员
类Y的成员可以访问类X的私有成员
仅类Y的公共成员可访问类X的私有成员

17 静态成员函数没有（）。
返回值
喵查答案：this 指针
指针参数
返回类型

18 已定义类A： class A { public: int x; static int y; }; int A::y = 0;下列语句中错误的是（）。

A::y = 1;
喵查答案：A.x = 1; A.y = 1;
A a; a.x = 1; a.y = 1;
A a; a.x = 1; A::y = 1;

19 友元的作用之一是（）。
喵查答案：提高程序的运行效率
加强类的封装
实现数据的隐蔽性
增加成员函数的种类

20 友元关系不能（）。
喵查答案：继承
是类与类之间的关系
是一个类的成员函数与另一个类的关系
提高程序的运行效率

21 下面关于友元的描述中，错误的是（）。
友元函数可以访问该类的私有数据成员
一个类的友元类中的成员函数都是这个类的友元函数
友元可以提高程序的运行效率
喵查答案：类与类之间的友元关系可以传递

22 下面关于静态成员函数的叙述中错误的是（）。
静态成员函数可以有返回值
喵查答案：this指针可以指向静态成员函数
静态成员函数可以具有指针参数
静态成员函数可有返回值类型

23 下面对于友元函数描述正确的是（　　）。
友元函数的实现必须在类的内部定义
友元函数是类的成员函数
喵查答案：友元函数从表面上看破坏了类的封装性和隐藏性
友元函数不能访问类的私有成员

24 下面对静态数据成员的描述中，正确的是（　　）。
静态数据成员可以在类体内进行初始化
静态数据成员不可以被类的对象调用
静态数据成员不能受private控制符的作用
喵查答案：静态数据成员可以直接用类名调用

25 下列关于友元函数的描述中，错误的是（）。
友元函数不是成员函数
喵查答案：友元函数只可访问类的私有成员
普通函数作为友元函数时，其调用方法同一般函数
友元函数可以是另一类中的成员函数

26 下列关于友元的描述错误的是（）。
喵查答案：成员函数不可作友元
类可以作友元
普通函数可以作友元
静态函数可以作友元

27 下列关于静态数据成员的说法，不正确的是（）。
类中定义的公用静态数据成员，可以通过类的对象来访问
类中定义的所有静态数据成员，都必须在类外初始化
喵查答案：静态数据成员不是所有对象所共用的
普通的成员函数可以直接访问类中的静态数据成员

28 下列关于静态成员的描述中，错误的是（）。
静态成员都是使用static来说明的
静态成员是属于类的，不是属于某个对象的
喵查答案：静态成员只可以用类名加作用域运算符来引用，不可用对象引用
静态数据成员的初始化是在类体外进行的

29 下列访问公有静态成员的方式，错误的是（）。
类名:: 静态成员名
对象名.静态成员名
对象指针->静态成员名
喵查答案：对象指针.静态成员名

30 （）只能访问静态成员变量。
喵查答案：静态成员函数
虚函数
构造函数
析构函数

31 （）的功能是对对象进行初始化。
析构函数
数据成员
喵查答案：构造函数
静态数据成员

32 类的静态成员的访问控制（）。
只允许被定义为private
只允许被定义为private或protected
只允许被定义为public
喵查答案：可允许被定义为private、protected或public

33 一个类的静态数据成员所表示属性（）。
是类的或对象的属性
只是对象的属性
喵查答案：只是类的属性
类和友元的属性

34 非静态成员函数都会有一个隐含指针，它是（）。
self指针
喵查答案：this指针
current指针
one指针

35 对于友元描述正确的是（）。
友元是本类的成员函数
喵查答案：友元不是本类的成员函数
友元不是函数
友元不能访问本类私有成员

36 若类X是类Y的友元类，则下列访问关系中（）是正确的。
类X的成员不能访问类Y的私有成员
喵查答案：类X的成员可以访问类Y的私有成员
类Y的成员可以访问类X的私有成员
仅类Y的公共成员可访问类X的私有成员

37 静态成员函数没有（）。
返回值
喵查答案：this 指针
指针参数
返回类型

38 已定义类A： class A { public: int x; static int y; }; int A::y = 0;下列语句中错误的是（）。

A::y = 1;
喵查答案：A.x = 1; A.y = 1;
A a; a.x = 1; a.y = 1;
A a; a.x = 1; A::y = 1;

39 友元的作用之一是（）。
喵查答案：提高程序的运行效率
加强类的封装
实现数据的隐蔽性
增加成员函数的种类

40 友元关系不能（）。
喵查答案：继承
是类与类之间的关系
是一个类的成员函数与另一个类的关系
提高程序的运行效率

41 友元访问类的对象的成员时使用（）。
类的成员名
this指针指向成员名
“类名：：成员名”的形式
喵查答案：“对象名.成员名”的形式

42 由于数据隐藏的需要，静态数据成员通常被说明为（）。
喵查答案：私有的
公有的
保护的
不可访问的

43 已知类A是类B的友元，类B是类C的友元，则（　　）。
类A一定是类C的友元
类C一定是类A的友元
类C的成员函数可以访问类B的对象的任何成员
喵查答案：类A的成员函数可以访问类B的对象的任何成员

44 一个类的友元函数或友元类能够通过成员操作符访问该类的（）。
私有成员
公有成员
保护成员
喵查答案：公有成员、保护成员和私有成员

45 一个类的所有对象共享的是（）。
私有数据成员
公有数据成员
保护数据成员
喵查答案：静态数据成员

46 下面有关友元函数的描述中，正确的说法是（）。
喵查答案：友元函数是独立于当前类的外部函数
一个友元函数不可以同时定义为两个类的友元函数
友元函数必须在类的外部进行定义
在类的外部定义友元函数时必须加上friend关键字

47 下面有关静态成员函数的描述中，正确的是（）。
在静态成员函数中可以使用this指针
喵查答案：在建立对象前，就可以为静态数据成员赋值
静态成员函数在类外定义是，要用static前缀
静态成员函数只能在类外定义

48 有如下程序：#include using namespace std; class Sample { friend int fun(Sample s); public: Sample(int a ) {x=a;} private: int x; }; int fun(Sample s) { if(s.x<2) return 1; return s.x*fun(Sample(s.x -1)); } int main() { int sum=0; for(int i=0;i<6;i++) sum+=fun(Sample(i)); cout<<sum; return 0; }运行时输出的结果是( )。
120
16
喵查答案：154
34

49 有如下程序：#include using namespace std; class A{ public: static int a; void init(){a=1;} A(int a=2){init();a++;} }; int A::a=0; A obj; int main() { cout<<obj.a; return 0; }运行时输出的结果是( )。
0
喵查答案：1
2
3

50 下面程序的运行结果为( )。　#include using namespace std; class A { 　　static int n; 　public：　　A(){n=1;} 　　A(int num){n=num;} 　　void print(){cout<<n;} }; int A::n=2; void main() { 　　A a,b(3); 　　a.print(); 　　b.pint(); }
11
13
23
喵查答案：33

51 下面程序的结果为( )。#include int c; class A { private: int a; static int b; public: A(){a=0; c=0;} void seta(){a++;} void setb(){b++;} void setc(){c++;} void display(){cout << a << " " << b << " " << c;} }; int A::b = 0; void main() { A a1,a2; a1.seta(); a1.setb(); a1.setc(); a2.seta(); a2.setb(); a2.setc(); a2.display(); }
1 2 1
喵查答案：1 2 2
1 1 2
2 2 2

52 下面对静态数据成员的描述中，正确的是（）。
喵查答案：静态数据成员是类的所有对象共享的数据
类的每个对象都有自己的静态数据成员
类的不同对象有不同的静态数据成员值
静态数据成员不能通过类的对象调用

53 静态成员遵循类的其他成员所遵循的访问限制，除了（）。
静态成员函数
喵查答案：静态数据成员初始化
私有静态数据成员
公有静态成员函数

54 关于友元的描述中，（　　）是错误的。
喵查答案：友元函数是成员函数，它被说明在类体内
友元函数可直接访问类中的私有成员
友元函数破坏封装性
友元类中的所有成员函数都是友元函数

55 关于类的静态成员函数描述错误的是( )。
喵查答案：在创建对象前不存在
可以定义为类中的任何访问类型
不能直接访问非静态函数
不是某个对象的成员

56 关于静态成员的描述中，（）是错误的。
静态成员可分为静态数据成员和静态成员函数
喵查答案：静态数据成员定义后必须在类体内进行初始化
静态数据成员初始化不使用其构造函数
静态数据成员函数中不能直接引用非静态成员

57 下列静态数据成员的特性中（）是错误的。
说明静态数据成员时前边要加修饰符static
静态数据成员要在类体外进行初始化
喵查答案：静态数据成员不是所有对象所共用的
引用静态数据成员时，可以在其名称前加和作用域运算符

58 对静态成员的不正确描述是（）。
静态成员不属于对象，是类的共享成员
静态数据成员要在类外初始化
喵查答案：调用静态成员函数时要通过类或对象激活，所以静态成员函数拥有this指针
非静态成员函数也可以操作静态数据成员

59 关于this指针的说法错误的是（）。
喵查答案：this指针必须显示说明
当创建一个对象后，this指针就指向该对象
成员函数拥有this指针
静态成员函数不拥有this指针

60 一个类的友元不是该类的成员，与该类的关系密切，所以它（）。
有this指针，有默认操作的对象
没有this指针，可以有默认操作的对象
有this指针，不能执行默认操作
喵查答案：没有this指针，也就没有默认操作的对象

61 一个类的成员函数也可以成为另一个类的友元函数，这时的友元说明（）。
喵查答案：需加上类域的限定
不需加上类域的限定
类域的限定可加可不加
不需要任何限定

62 引入友元的主要目的是为了（）。
增强数据安全性
提高程序的可靠性
喵查答案：提高程序的效率和灵活性
保证类的封装性

63 当将一个类A或函数f()说明为另一个类B的友元后，类A或函数f()能够直接访问类B的（）。
只能是公有成员
只能是保护成员
只能是除私有成员之外的任何成员
喵查答案：具有任何权限的成员

64 静态数据成员的初始化是在（）中进行的。
构造函数
任何成员函数
所属类
喵查答案：全局区

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

66 静态成员函数对类的数据成员直接访问（）。
是不允许的
喵查答案：只允许是静态数据成员
只允许是非静态数据成员
可允许是静态数据成员或非静态数据成员

67 一个类的友元函数或友元类能够通过成员操作符访问该类的（）。
私有成员
保护成员
公有成员
喵查答案：所有成员

68 下面关于友元的描述中，错误的是（）。
友元函数可以直接访问该类的私有成员。
一个类的友元类中的所有成员函数都是这个类的友元函数。
利用友元可以提高程序的运行效率，但却破坏了封装性。
喵查答案：友元关系不能被继承，是双向可交换的。

69 已知f1和f2是同一类的两个成员函数，但f1不能直接调用f2，这说明（）。
f1和f2都是静态函数
f1不是静态函数，f2是静态函数
喵查答案：f1是静态函数，f2不是静态函数
f1和f2都不是静态函数

70 若要把函数void f()定义为类aClass的友元函数，则应该在类aClass定义中加入的语句是（）。
void f()
static void f()
friend f()
喵查答案： friend void f()

71 （　）是类的所用对象共享的成员，而不是某个对象的成员。
喵查答案：静态成员
动态成员
内联函数
析构函数

72 关于友元，下列说法正确的是（）。
喵查答案： A 类为 B 类的友元类，则A 类中的所有函数就可以访问 B 类中的所有成员
友元函数的定义在类体中
友元只能是类
友元只能是函数

73 有如下程序：# include class Toy { public: Toy(char* _n) { strcpy(name, _n); count++; } ~Toy( ) { count--; } char* GetName( ) { return name; } static int getCount( ) { return count; } private: char name[10]; static int count; }; int Toy::count=0; int main( ) { Toy t1("Snoopy"), t2("Mickey"), t3("Barbie"); cout<<t1.getCount( )<<endl; return 0; }运行时的输出结果是( )。
1
2
喵查答案：3
运行时出错

74 以下关于this指针的叙述中正确的是（）。
任何与类相关的函数都有this指针
类的成员函数都有this指针
类的友元函数都有this指针
喵查答案：类的非静态成员函数才有this指针

75 下列关于静态数据成员的描述中，正确的是（）。
喵查答案：静态数据成员是类的所有对象所共有的
静态数据成员要在构造函数内初始化
类的每个对象有自己的静态数据成员
静态数据成员不能通过类的对象调用

76 下面对友元的错误描述是（）。
关键字friend用于声明友元
一个类的成员函数可以是另一个类的友元
友元函数访问对象的成员不受访问特性影响
喵查答案：友元函数通过this指针访问对象成员

77 声明友元使用下列哪个关键字（）。
class
const
喵查答案：friend
virtual

78 设类Test中存在成员static int x，则下列哪种初始化方式是正确的（）。
Test::int x=25；
int x=25；
喵查答案：int Test::x=25；
int Test x=25；

79 如果在类外有函数调用CPoint::func()；则函数func()是类CPoint的（）。
私有静态成员函数
公有非静态成员函数
喵查答案：公有静态成员函数
友元函数

80 如果类A被声明成类B的友元，则( )。
类A的成员即类B的成员
类B的成员即类A的成员
类A的成员函数不得访问类B的成员
喵查答案：类B不一定是类A的友元

81 如果类 B 被说明成类 A 的友元，则（　　）。
类 A 的成员即类 B 的成员
喵查答案：类 B 的成员函数可以访问类 A 的成员
类 B 的成员即类 A 的成员
类 A 也是类 B 的友元

82 类A是类B的友元,类B是类C的友元,则( )是正确的。
类B是类A的友元
类C是类A的友元
类A是类C的友元
喵查答案：以上都不对

83 可以在类的构造函数中对静态数据成员进行初始化。
正确
喵查答案：错误

84 在一个类的对象空间里已经包含了静态成员的空间。
正确
喵查答案：错误

85 在一个类的对象空间里不包含静态成员的空间。
喵查答案：正确
错误

86 友元类中的所有成员函数都是友元函数。
喵查答案：正确
错误

87 友元函数是说明在类体内的非成员函数，它可以访问类中的所有成员。
喵查答案：正确
错误

88 友元函数是类的成员函数，所以可以存取或修改该类中的私有成员。
正确
喵查答案：错误

89 友元本身就是类的成员。
正确
喵查答案：错误

90 可以把一个一般函数说明为某类的友元函数，也可以将某类的成员函数说明为另类的友元函数。
喵查答案：正确
错误

91 静态数据成员必须在构造函数的成员初始化列表中进行初始化。
正确
喵查答案：错误

92 静态成员函数中引用静态数据成员和非静态数据成员的方式是相同的。
正确
喵查答案：错误

93 公有的静态成员可以使用类名加作用域运算符的方法来引用。
喵查答案：正确
错误

94 某类中的友元类的所有成员函数可以存取或修改该类中的私有成员。
喵查答案：正确
错误

95 友元函数访问对象中的成员可以不通过对象名。
正确
喵查答案：错误

96 友元函数是在类声明中由关键字friend修饰说明的类的成员函数。
正确
喵查答案：错误

97 静态成员函数可以引用属于该类的任何函数成员。
正确
喵查答案：错误

98 静态数据成员必须在类外初始化。
喵查答案：正确
错误

99 当将一个类S定义为另一个类A的友元类时，类S的所有成员函数都可以访问类A的所有成员。
喵查答案：正确
错误

100 类的静态数据成员需要在定义每个类的对象时进行初始化。
正确
喵查答案：错误

101 静态变量在整个程序的运行过程中始终都是存在着的。
喵查答案：正确
错误

102 C＋＋允许使用友元，但是友元会破坏封装性。
喵查答案：正确
错误

103 如果一个成员函数只存取类的静态数据成员，则可将该成员函数说明为静态成员函数。
喵查答案：正确
错误

104 类的公有静态成员既可以用类的对象访问，也可以用作用域运算符通过类名访问。
喵查答案：正确
错误

105 友元类的声明可以放在类定义中的任何地方。
喵查答案：正确
错误

106 静态成员变量是整个类的所有对象共用的。
喵查答案：正确
错误

107 在成员函数中访问对象的数据成员时，可以直接用数据成员名，而在友元函数中访问对象的数据成员时，必须指明是哪个对象的数据成员。
喵查答案：正确
错误

第2章继承性（2周）

1 继承与派生可以给软件开发带来很多好处，下述中不正确的是（）。

避免公用代码的重复开发，提高了程序开发的效率和质量
可以减少代码和数据的冗余
通过层次关系组织对象，给编码与代码重用带来了方便
喵查答案：

软件的执行效率大大提高

2 有以下定义的派生类：class A:public B{ … };则下面描述中正确的是（）。

A类中的成员函数可以访问B类中的private 数据成员
A类中的成员函数只能访问B类中的protected数据成员。
喵查答案：

A类中的成员函数可以访问B类中的public数据成员。
A类中的成员函数只能访问B类中的public数据成员

3 派生类由protected方式继承基类成员，则（）。

基类中的私有成员成为派生类中的私有成员。
基类中的保护成员成为派生类中的私有成员。
基类中的公有成员成为派生类中的私有成员。
喵查答案：

基类中的公有成员成为派生类中的保护成员。

4 派生类由public方式继承基类成员，则（）。

基类中的私有成员可以被派生类的成员函数访问。
基类中的保护成员不能被派生类的成员函数访问。
喵查答案：基类中的公有成员可以被派生类的成员函数访问。
以上都不正确

5 若要用派生类的对象访问基类的保护成员，以下观点正确的是（）。
喵查答案：不能直接访问
可采用保护继承
可采用私有继承
可采用公有继承

6 以下关于派生机制的描述中，不正确的是（）。

派生类不仅可以继承基类的成员，也可以添加自己的成员
设置protected成员是为派生类访问基类成员之用
采用不同的继承方式，将限制派生类对基类成员的访问
喵查答案：

采用私有继承，派生类只能得到基类的公有成员

7 以下关于私有和保护成员的叙述中，不正确的是（）。
喵查答案：

私有成员不能被外界引用，保护成员可以
私有成员不能被派生类引用，保护成员在公有继承下可以
私有成员不能被派生类引用，保护成员在保护继承下可以

私有成员不能被派生类引用，保护成员在私有继承下可以

8 通过派生类的对象可直接访问其（）。
喵查答案：公有继承基类的公有成员
公有继承基类的私有成员
私有继承基的公有成员
私有继承基类的私有成员

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

10 设W是U的公有派生类，U中的保护性数据成员a，被继承到W中后其访问属性是( )。
公有的
私有的
喵查答案：保护的
不能直接被访问

11 不论派生类以何种方法继承基类，都不能使用基类的（）。
public成员
喵查答案：private成员
protected成员
public成员和protected成员

12 下面叙述不正确的是（）。
喵查答案：基类的保护成员在派生类中是保护的
基类的保护成员在公有派生类中仍然是保护的
基类的保护成员在私有派生类中仍然是私有的
对基类成员的访问必须是无两义性

13 下面描述中，表达错误的是（）。

公有继承时基类中的public成员在派生类中仍是public的
喵查答案：公有继承时基类中的private成员在派生类中仍是private的
公有继承时基类中的protected成员在派生类中仍是protected的

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

14 下面程序段中，说法正确的是（）。class location{ public : int GetX(); }; class rectangle:private location { public: int GetW(); };

类rectangle私有派生类 location
类rectangle中的public成员在类 location中是私有的类
location中的public成员在类 rectangle中是不可访问的
喵查答案：

viod f( ) {

Rectangle r;

int X=r .GetX( );

}

其中int X = r .GetX( );是非法语句

15 下列说法中错误的是（）。

公有继承时基类中的public成员在派生类中是public的
保护继承时基类中的public成员在派生类中是protected的
私有继承时基类中的public成员在派生类中是private的
喵查答案：

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

16 下列描述中，错误的是（）。

基类的protected成员在public派生类中仍然是protected成员
基类的private成员在public派生类中是不可访问的
基类public成员在private派生类中是private成员
喵查答案：

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

17 下面叙述错误的是（）。
喵查答案：

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

基类的protected成员不能被派生类的对象访问

18 下列关于继承的描述中，错误的是（）。
通过继承，可吸收现有类的数据和函数来创建新类，并增添新的成员增强此类，这样可以节约程序开发的时间
基类是对派生类的抽象，派生类是对基类的具体化
派生类的成员除了它自己的成员外，还包含了它的基类的成员
喵查答案：派生类中继承的基类成员的访问权限到派生类保持不变

19 C++中的类有两种用法：一种是类的实例化，即生成类的对象，并参与系统的运行；另一种是通过（）_派生出新的类。
复用
喵查答案：继承
封装
引用

20 以下有关继承的叙述正确的是（）。
构造函数和析构函数都能被继承
派生类是基类的子集
喵查答案：派生类对象能访问自己的公有成员，不能访问基类的私有和保护成员
基类的公有成员一定能被派生类的对象访问

21 继承与派生可以给软件开发带来很多好处，下述中不正确的是（）。

避免公用代码的重复开发，提高了程序开发的效率和质量
可以减少代码和数据的冗余
通过层次关系组织对象，给编码与代码重用带来了方便
喵查答案：

软件的执行效率大大提高

22 有以下定义的派生类：class A:public B{ … };则下面描述中正确的是（）。

A类中的成员函数可以访问B类中的private 数据成员
A类中的成员函数只能访问B类中的protected数据成员。
喵查答案：

A类中的成员函数可以访问B类中的public数据成员。
A类中的成员函数只能访问B类中的public数据成员

23 派生类由protected方式继承基类成员，则（）。

基类中的私有成员成为派生类中的私有成员。
基类中的保护成员成为派生类中的私有成员。
基类中的公有成员成为派生类中的私有成员。
喵查答案：

基类中的公有成员成为派生类中的保护成员。

24 派生类由public方式继承基类成员，则（）。

25 若要用派生类的对象访问基类的保护成员，以下观点正确的是（）。
喵查答案：不能直接访问
可采用保护继承
可采用私有继承
可采用公有继承

26 以下关于派生机制的描述中，不正确的是（）。

采用私有继承，派生类只能得到基类的公有成员

27 以下关于私有和保护成员的叙述中，不正确的是（）。
喵查答案：

私有成员不能被派生类引用，保护成员在私有继承下可以

28 通过派生类的对象可直接访问其（）。
喵查答案：公有继承基类的公有成员
公有继承基类的私有成员
私有继承基的公有成员
私有继承基类的私有成员

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

30 设W是U的公有派生类，U中的保护性数据成员a，被继承到W中后其访问属性是( )。
公有的
私有的
喵查答案：保护的
不能直接被访问

31 不论派生类以何种方法继承基类，都不能使用基类的（）。
public成员
喵查答案：private成员
protected成员
public成员和protected成员

32 下面叙述不正确的是（）。
喵查答案：基类的保护成员在派生类中是保护的
基类的保护成员在公有派生类中仍然是保护的
基类的保护成员在私有派生类中仍然是私有的
对基类成员的访问必须是无两义性

33 下面描述中，表达错误的是（）。

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

34 下面程序段中，说法正确的是（）。class location{ public : int GetX(); }; class rectangle:private location { public: int GetW(); };

类rectangle私有派生类 location
类rectangle中的public成员在类 location中是私有的类
location中的public成员在类 rectangle中是不可访问的
喵查答案：

viod f( ) {

Rectangle r;

int X=r .GetX( );

}

其中int X = r .GetX( );是非法语句

35 下列说法中错误的是（）。

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

36 下列描述中，错误的是（）。

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

37 下面叙述错误的是（）。
喵查答案：

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

基类的protected成员不能被派生类的对象访问

38 下列关于继承的描述中，错误的是（）。
通过继承，可吸收现有类的数据和函数来创建新类，并增添新的成员增强此类，这样可以节约程序开发的时间
基类是对派生类的抽象，派生类是对基类的具体化
派生类的成员除了它自己的成员外，还包含了它的基类的成员
喵查答案：派生类中继承的基类成员的访问权限到派生类保持不变

39 C++中的类有两种用法：一种是类的实例化，即生成类的对象，并参与系统的运行；另一种是通过（）_派生出新的类。
复用
喵查答案：继承
封装
引用

40 以下有关继承的叙述正确的是（）。
构造函数和析构函数都能被继承
派生类是基类的子集
喵查答案：派生类对象能访问自己的公有成员，不能访问基类的私有和保护成员
基类的公有成员一定能被派生类的对象访问

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

42 在公有派生类的成员函数不能直接访问基类中继承来的某个成员，则该成员一定是基类中的（）。
喵查答案：私有成员
公有成员
保护成员
保护成员或私有成员

43 对于下述程序，如果将第①句中的“protected:”去掉，则编译时（）。 #include class Base ｛ protected: //① int Base_pro; public: void set(int i) ｛ Base_pro=i; ｝｝; class Derived : public Base //② ｛ int Drv_pri; public: void DrvSet(int i,int j) ｛ Drv_pri=i; set(j); //③ ｝ void display() ｛ cout<<""\nDrv_pri = ""<< Drv_pri; cout<<""\nBase_pro = ""<< Base_pro; //④ ｝｝; void main() ｛ Derived d; d.DrvSet(3,6); d.display(); ｝

第③、④两句都出错
第③句出错，第④句对
喵查答案：第③句对，第④句出错
第③、④两句都对

44 类的成员若能被本类的成员函数所访问,也能被该类的派生类直接访问，但不能被外界直接访问（友元除外），则这样的类成员是（）。
私有（private:）成员
公有（public:）成员
喵查答案：保护（protected:）成员
都不是

45 下面关于继承的描述中，错误的是（）。
析构函数不能被继承
派生类是基类的延续
派生类的成员除了它自己的成员外，还包含了它的基类成员
喵查答案：派生类中继承的基类成员的访问权限到派生类保持不变

46 派生类的成员函数不能访问基类的（）。
公有成员和保护成员
公有成员
保护成员
喵查答案：私有成员

47 下面关于继承的描述中，错误的是( )。
继承描述的是类的层次关系，派生类可以具有与基类相同的属性和方法
一个基类可以有多个派生类，一个派生类可以有多个基类
C++有两种继承包括单一继承和多重继承
喵查答案：静态成员不可以被继承

48 下面叙述正确的是( )。
喵查答案：派生类可以有自己的构造函数
派生类继承基类的构造函数
派生类继承基类的析构函数
派生类只能继承基类的一个构造函数

49 下面关于基类与派生类的访问控制规则的叙述，错误的是（）。

不管是何种派生，基类的private成员都不能被其派生类访问
在派生类中访问基类的private成员可以通过基类的public和protected成员函数访问
喵查答案：

当通过private继承时，基类中的protected成员数据不能被派生类的成员函数访问
当通过public继承时，基类中的protected成员数据可以被派生类的成员函数访问

50 设有如下定义的基类与派生类：class cBase{ public: int x; void setx(int a){x=a;}; protected: int y; private: int z; }; class cDerived:protected cBase{ public: void sety(int a){y=a;}; };实例化对象：cDerived cc;则下面哪条语句是正确的（）。

cc.x=1;
cc.y=2;
cc.setx(5);
喵查答案：cc.sety(4);

51 有以下定义的类及变量：class B{ public: B(){b=0;}; protected:: int b; }; class A:private B { public: int get(){return b;} }; B cB; A cA; int a;则下面语句中正确的是（）。

a=cA.b;
喵查答案：a=cA.get();
a=cB.b;

其他都不对

52 设有基类定义：class cBase{ private: int a; protected: int b; public: int c; };派生类采用何种继承方式可以使成员变量b成为自己的私有成员（）。
喵查答案：

私有继承
保护继承
公有继承
其他都可以

53 对于多重继承，有（）。
一个派生类只能有一个基类
一个基类只能产生一个派生类
一个基类必须产生多个派生类
喵查答案：一个派生类可有多个基类

54 在C++中，对于基类的protected成员，当以protected方式派生一个新类时，该成员将成为派生类的（）成员。
private
喵查答案：protected
public
非法

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

56 假定类A已经定义，对于以A为基类的单一继承类B，以下定义中正确的是（）。
喵查答案：class B:public A{//…};
class A:public B{//…};
class B:public class A{//…};
class A:class B public{//…};

57 不论派生类以何种方法继承基类，都不能使用基类的（）。
public成员
喵查答案：private成员
protected成员
public成员和protected成员

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

59 下列关于类的继承描述中，（）是错误的。
喵查答案：派生类可以访问基类的所有数据成员，也能调用基类的所有成员函数
派生类也可以是其他类的基类，但基类不一定具有派生类的全部属性和方法
继承描述类的层次关系，派生类可以具有与基类相同的属性和方法
一个基类可以有多个派生类，一个派生类可以有多个基类

60 派生类的对象对其基类中（）可直接访问。
喵查答案：公有继承的公有成员
公有继承的私有成员
公有继承的保护成员
私有继承的公有成员

61 下列对派生类的描述中错误的说法是（）。
派生类至少有一个基类
派生类可作为另一个派生类的基类
派生类除了包含它直接定义的成员外，还包含其基类的成员
喵查答案：派生类所继承的基类成员的访问权限保持不变

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

63 当保护继承时，基类的（）在派生类中成为保护成员，在类作用域外不能够通过派生类的对象来直接访问该成员。
任何成员
喵查答案：公有成员和保护成员
保护成员和私有成员
私有成员

64 对于公有继承，基类中的私有成员在派生类中将（）。
能够直接使用成员名访问
能够通过成员运算符访问
喵查答案：仍然是基类的私有成员
变为派生类的私有成员

65 对于公有继承，基类的公有和保护成员在派生类中将（）成员。
全部变成公有
全部变成保护
全部变成私有
喵查答案：仍然相应保持为公有和保护

66 派生类的成员函数可以直接访问基类的（）成员。
所有
喵查答案：公有和保护
保护和私有
私有

67 C++的继承性允许派生类继承基类的（）。（注：以下描述中特性不包括构造和析构函数）
部分特性，并允许增加新的特性或重定义基类的特性
部分特性，但不允许增加新的特性或重定义基类的特性
喵查答案：所有特性，并允许增加新的特性或重定义基类的特性
所有特性，但不允许增加新的特性或重定义基类的特性

68 从一个基类派生出的各个类的对象之间（）。
共享所有数据成员，每个对象还包含基类的所有属性
共享部分数据成员，每个对象还包含基类的所有属性
喵查答案：不共享任何数据成员，但每个对象还包含基类的所有属性
共享部分数据成员和函数成员

69 下列关于继承的描述中，错误的是（）。
继承是重用性的重要机制
喵查答案：C++语言只支持单重继承和双重继承
继承关系不是可逆的
继承是面向对象程序设计语言的重要特性

70 下列关于基类和派生类的描述中，错误的是（）。
一个基类可以生成多个派生类
派生类可以作为基类继续派生
喵查答案：基类中成员访问权限继承到派生类中不变
派生类中除了继承的基类成员还有自己的成员

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

72 使用派生类的主要原因是（）。
喵查答案：提高代码的可重用性
提高程序的运行效率
加强类的封装性
实现数据的隐藏

73 若派生类的成员函数不能直接访问基类中继承来的某个成员，则该成员一定是基类中的（）。
喵查答案：私有成员
公有成员
保护成员
保护成员或私有成员

74 若类A和类B的定义如下：class A { int i,j; public: void get(); file://… }; class B:A//默认为私有派生 { int k; public; void make(); file://… }; void B:: make() { k=i*j;}则上述定义中，( )是非法的表达式。

void get();

int k;
void make();
喵查答案：k=i*j;

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

76 建造新的派生类是（）的实质。
派生
抽象
喵查答案：继承
封装

77 假设已经定义好了类student，现在要定义类derived，它是从student私有派生的，则定义类derived的正确写法是（）。

class derived:student private{ //………….}
class derived:student public { //………….}

class derived:public student { //………….}
喵查答案：class derived:student{ //………….}

78 继承机制的作用是（　　）。
信息隐藏
数据封装
喵查答案：派生新类
数据抽象

79 基类中的protected成员，通过public派生，其在派生类中的可见性为（）。
不可访问
private
喵查答案：protected
public

80 基类和派生类可以分别称为（）。
“大类”和“小类”
喵查答案：“父类”和“子类”
“小类”和“大类”
“子类”和“父类”

81 基类private成员，通过public派生，其在派生类中为（）。
private
protected
public
喵查答案：不可访问

82 关于保护继承的说法正确的是（）。
基类的公有成员、私有成员可被子类继承下来，而且性质不变。
基类的公有成员、私有成员可被子类继承下来，而且性质改变为保护成员。
基类的公有成员、私有成员可被子类继承下来，而且性质均改变为私有成员。
喵查答案：基类的公有成员、私有成员可被子类继承下来，公有成员性质改变为保护成员，私有成员不能被派生类直接访问。

83 关于保护成员的说法正确的是（）。
在派生类中仍然是保护的
喵查答案：具有私有成员和公有成员的双重角色
在派生类中是私有的
在派生类中是公有的

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

85 有如下程序：#include using namespace std; class A { public: A(int i){x=i;} void dispa(){cout<<x<<’,’;} private: int x; }; class B:public A { public: B(int i):A(i+10){x=i;} void dispb(){dispa();cout<<x<<endl;} private: int x; }; int main() { B b(2); b.dispb(); return 0; }运行时输出的结果是（）。
10, 2
12,10
喵查答案：12,2
2,2

86 有如下类声明：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

87 设有如下程序：#include class A { public: int i; display() { cout<<”class A\n”; } }; class B { public: int i; display() { cout<<”class B\n”; } }; class C: public: A, public B { int j; public: int i; show() {j=i*i; display();} }; void main() { C demo; demo.show(); }主程序运行时将( )。
因变量i的重复定义而报错
因对象demo间接调用display函数时产生歧义性而报错
喵查答案：因类定义的语法错而不能运行
没有语法错，正常输出结果

88 设有基类定义： class base { private: int a; protected: int b; public: int c; };派生类采用何种继承方式可以使成员变量c能被派生类的对象直接访问( )。

私有继承
保护继承
喵查答案：公有继承

私有、保护、公有均可

89 下列说法错误的是（）。

公有继承的基类中的public成员在派生类中仍是public的
喵查答案：公有继承的基类中的private成员在派生类中仍是private的
私有继承的基类中的public成员在派生类中变成private的

保护继承的基类中的public成员在派生类中变成protected的

90 以下四个关于类的访问控制的描述哪一个是错误的（）。
子类不能访问其父类的私有数据成员和成员函数
子类的对象不能访问其父类的保护数据成员或者成员函数
类的对象不能访问类的保护数据成员或者成员函数
喵查答案：类的成员函数不能访问类中的私有数据

91 在公有继承的情况下，基类的私有成员在派生类中的访问权限是（　）。
喵查答案：不可访问　　　
可以访问
公有的
保护的

92 在公有继承的情况下，基类的私有成员在派生类中的访问权限是（　）。
喵查答案：不可访问　　　
可以访问
公有的
保护的

93 多重继承是（）。
多个单一继承的叠加
喵查答案：派生类有多个直接基类
多个派生类有唯一的基类
每个派生类最多只有一个直接基类，但它可以有多个间接基类

94 在 C++中的类有两种方法：一种是类的实例化，即生成类的对象，并参与系统的运行；另一种是通过( )，派生出新的类。
复用
喵查答案：继承
单继承
多继承

95 有如下类声明，则类MyDERIVED中保护的数据成员和成员函数的个数是（）。class MyBASE {private: int k; protected: int x; public: void set(int m,int n){ k=m;x=n;} int get( )const{ return k;} }; class MyDERIVED: protected MyBASE { protected: int j; public: void set(int m, int n,int p){ MyBASE::set(m,n); j=p;} int get( ) const { return MyBASE::get( )+j; } };
喵查答案：4
3
2
1

96 有如下程序：#include using namespace std; class AA { int k; protected: int n; void setK(int k){ this->k=k; } public: void setN(int n){ this->n=n; } }; class BB: public AA { /*类体略*/ }; int main( ) { BB x; x.n=l; //1# x.setN(2); //2# x.k=3; //3# x.setK(4); //4# return 0; }在标注号码的四条语句中正确的是( )。
1
喵查答案：2
3
4

97 应在下列程序划线处填入的正确语句是（）。 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();

98 this指针存在的目的是（）。
保证基类公有成员在子类中可以被访问
喵查答案：保证每个对象拥有自己的数据成员，但共享处理这些数据成员的代码
保证基类保护成员在子类中可以被访问
保证基类私有成员在子类中可以被访问

99 下列关于成员访问权限的描述中，不正确的是（）。
公有数据成员和公有成员函数都可以被类对象直接处理
喵查答案：类的私有数据成员只能被公有成员函数以及该类的任何友元类或友元函数访问
保护成员在派生类中可以被访问，而私有成员不可以
只有类或派生类的成员函数和友元类或友元函数可以访问保护成员

100 基类的成员在派生类中都是可以访问的。
正确
喵查答案：错误

101 若类Y是类X的私有派生类，类Z是类Y的公有派生类，则类Z不能访向类X的公有成员和保护成员。
喵查答案：正确
错误

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

103 保护继承时，派生类中的成员函数可以直接访问基类中的protected成员。
喵查答案：正确
错误

104 基类中被说明为protected和private的成员只能被其派生类的成员函数访问，不能被其它的函数访问。
正确
喵查答案：错误

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

106 析构函数不能被继承。
喵查答案：正确
错误

107 构造函数可以被继承。
正确
喵查答案：错误

108 派生类中至少包含了它的所有基类的成员(构造函数和析构函数除外),在这些成员中可能有的是不可访问。
喵查答案：正确
错误

109 在保护继承中,派生类的成员函数对基类成员的访问同于公有继承,而派生类对象对基类成员的访问同于私有继承。
喵查答案：正确
错误

110 派生类中只包含直接基类的成员，不包含间接基类的成员。
正确
喵查答案：错误

111 派生类中继承的基类成员的访问权限到派生类保持不变。
正确
喵查答案：错误

112 派生类中成员的访问权限与基类的继承方式有关。
喵查答案：正确
错误

113 派生类至少有一个基类。
喵查答案：正确
错误

114 派生类只继承基类中的公有成员和保护成员，而不继承私有成员。
正确
喵查答案：错误

115 派生类还可以作基类派生出新的派生类。
喵查答案：正确
错误

116 派生类的对象和派生类的派生类对派生类成员的访问权限是一样的。
正确
喵查答案：错误

117 基类中成员在派生类中都是可以访问的。
正确
喵查答案：错误

118 多重继承是指一个基类派生出多个派生类的情况。
正确
喵查答案：错误

119 单重继承是指派生类只有一个基类的情况。
喵查答案：正确
错误

120 保护继承方式下基类的保护成员在派生类仍是保护成员。
喵查答案：正确
错误

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

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

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

124 声明派生类时，在派生类的头部都要明确列出其直接基类和间接基类。
正确
喵查答案：错误

125 在保护继承中，基类中的公有成员对派生类对象是可见的。
正确
喵查答案：错误

126 在公有继承中，基类中的保护成员对派生类对象是可见的。
正确
喵查答案：错误

127 派生类的继承方式有两种：公有继承和私有继承。
正确
喵查答案：错误

128 在公有继承中，基类中只有公有成员对派生类的对象是可见的。
喵查答案：正确
错误

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

130 在私有继承中，派生类的对象不可直接访问基类中的任何成员。
喵查答案：正确
错误

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

132 在公有和保护继承方式下，派生类的对象可以对基类的保护成员进行访问。
正确
喵查答案：错误

133 在公有和保护继承方式下，派生类的成员可以对基类的保护成员进行访问。
喵查答案：正确
错误

134 无论是私有继承还是保护继承中，基类中所有成员对派生类对象都是不可见的。
喵查答案：正确
错误

135 私有继承中基类的私有成员在派生类中还是私有的。
正确
喵查答案：错误

136 私有继承中，基类中所有成员对派生类的对象来说都是不可直接访问的。
喵查答案：正确
错误

1 在公有派生情况下，有关派生类对象和基类对象的关系，下列叙述不正确的是( )。

派生类的对象可以赋给基类的对象
派生类的对象可以初始化基类的引用
喵查答案：派生类的对象可以直接访问基类中的成员

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

2 下列关于赋值兼容规则的描述中,( )是错误的。

赋值兼容规则在子类型情况下才可使用
喵查答案：公有继承下,派生类对象不可给基类对象赋值
公有继承下,派生类对象可对基类对象引用进行初始化

公有继承下,派生类对象的地址值可以赋值给基类的对象指针

3 设有以下类的定义：#include class A { protected: int a; public: A(int i=0) { a=i; } }; class B: public A { int b; public: B(int i=0, int j=0): A(j){ b=i; } };则下列语句中错误的是（）。
A *pa=new B;

A a1=B(2,9);
B b1(1,2); A *pa1=&b1;
喵查答案：A a1(8); B a2=a1;

4 在下列程序中，C类的数据成员中有一个A类对象和一个B类对象。#include class A { int a; public: A(int x=10) {a=x; } int GetA( ) { return a; } }; class B { int b; public: B(int x) {b=x; } int GetB( ) { return b; } }; class C { int c; A aobj; B bobj; public: C(int x, int y, int z): aobj(y),bobj(z) //E { c=x; } void print( ) { cout<<aobj.GetA()<<'\t'<< bobj.GetB()<<'\t'<<c<<endl ; } }; void main() { C cobj(3,6,8); cobj.print( ); }程序在E行定义了构造函数，如果将该行改为下列中（）选项时，便会出现编译错误。

C(int x, int y, int z): aobj(z),bobj(y)
C(int x, int y, int z): bobj(z)
喵查答案：

C(int x, int y, int z): aobj(y)
C(int x, int y, int z): aobj(z),bobj(y+z)

5 在一个派生类对象结束其生命周期时（）。
喵查答案：

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

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

6 有如下程序：#include class A { public: void func1( ){cout<<"A1";} void func2( ){cout<<"A2";} }; class B:public A { public: void func1( ){cout<<"B1";} void func2( ){cout<func1( ); p->func2( ); }执行该程序，将显示输出( )。
B1B2
喵查答案：A1A2
B1A2
A1B2

7 有如下程序：#include class TestClass { private: char c; public: TestClass (char n):c(n) { } ~TestClass() { cout<<c; } }; class TestClass1:public TestClass { private: char c; public: TestClass1(char n):TestClass (n+1),c(n) { } ~TestClass1() { cout<<c; } }; void main( ) { TestClass1 obj('x'); }执行上面的程序将输出( )。
喵查答案：

xy
yx
x
y

8 下面叙述不正确的是( )。
成员的访问能力在私有派生类中和公有派生类中是不同的
基类的私有成员在公有派生类中不可访问
喵查答案：赋值兼容规则不适用于多重继承的组合
基类公有成员在保护派生中是保护的

9 下面关于多重继承的叙述，正确的是（）。
c++不支持多重继承
多重继承是指从多层基类中派生出的子类
多重继承中派生类成员的访问控制规则与单一继承规则不相同
喵查答案：多重继承中可以通过虚基类防止二义性问题

10 当派生类从基类公有继承时，以下哪种说法是错误的（）。

可以用派生类对象为基类对象赋值。
喵查答案：可以用基类对象为派生类对象赋值。
可以把指向派生类对象的指针赋给基类对象的指针。

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

11 下面有关基类和派生类的说法中，错误的是( )。

派生类可以增添一些基类中没有的成员

派生类中可以出现与基类同名的成员（若是成员函数则参数的个数和类型相同），但会出现同名覆盖现象；若要引用或调用基类中同名的成员，必须用访问域控制符(基类::成员)加以指明
派生类可以重载基类中的成员函数
喵查答案：派生类可以有选择性地继承基类中的某些成员，删除不需要的成员

12 下面有关派生类的说法中，错误的是( )。

一个派生类可以作为另一个派生类的基类
一个派生类可以有多个基类
派生类构造函数可以将初始化参数值传递给基类的构造函数和对象成员的构造函数
喵查答案：

具有继承关系时，基类成员在派生类中的访问权限不变

13 有如下程序：# include using namespace std; class C1 { public: ~C1( ){ cout<<1; } }; class C2: public C1 { public: ~C2( ){ cout<<2; } }; int main( ) { C2 cb2; C1 *cb1; return 0; }运行时的输出结果是( )。

121
喵查答案：21
211
12

14 有如下程序：# include using namespace std; class AA { public: AA( ){ cout<<'1'; } }; class BB: public AA { int k; public: BB( ) : k(0) { cout<<'2'; } BB(int n) : k(n) { cout<<'3'; } }; int main( ) { BB b(4), c; return 0; }运行时的输出结果是( )。
喵查答案：1312
132
32
1412

15 有如下程序，执行后的输出结果应该是（）。#include class BASE{ public: ~BASE(){cout<<"BASE ";} }; class DERIVED: public BASE{ public: ~DERIVED(){cout<<"DERIVED ";} }; void main() { DERIVED x; }
BASE
DERIVED
BASE DERIVED
喵查答案：DERIVED BASE

16 有如下程序，执行后的输出结果应该是（）。#include class A{ public: A(){cout<<"A";} }; class C:public A{ public: C(){cout<<"C";} }; void main() {C cobj;}
喵查答案：AC
CA
A
C

17 有类定义如下：class X { int a; public: X( int x=0 ){ a=x; } }; class Y : public X { int b; public: Y( int x=0, int y=0 ) : X(y) { b=x; } };下列定义对象的语句组中出现语法错误的是（）。

X *pa=new Y(1,2);
X *a1=new X(1);
Y b1(2,3); X &a3=b1;
喵查答案： X a4(10); Y b2=a4;

18 关于多继承二义性的描述中，（）是错的。

一个派生类的两个基类中都有某个同名成员，在派生类中对这个成员的访问可能出现二义性
解决二义性的最常用的方法是对成员名的限定法
喵查答案：

基类和派生类中同时出现的同名函数，也存在二义性问题
一个派生类是从两个基类派生来的，而这两个基类又有一个共同的基类，对该基类成员进行访问时，也可能出现二义性

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

20 下面叙述不正确的是（）。
喵查答案：基类的公有成员在派生类中仍然是公有的
派生类一般常用公有派生
对基类成员访问必须是无二义性的
赋值兼容规则也使用于多重继承的组合

21 在公有派生情况下，有关派生类对象和基类对象的关系，下列叙述不正确的是( )。

派生类的对象可以赋给基类的对象
派生类的对象可以初始化基类的引用
喵查答案：派生类的对象可以直接访问基类中的成员

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

22 下列关于赋值兼容规则的描述中,( )是错误的。

赋值兼容规则在子类型情况下才可使用
喵查答案：公有继承下,派生类对象不可给基类对象赋值
公有继承下,派生类对象可对基类对象引用进行初始化

公有继承下,派生类对象的地址值可以赋值给基类的对象指针

23 设有以下类的定义：#include class A { protected: int a; public: A(int i=0) { a=i; } }; class B: public A { int b; public: B(int i=0, int j=0): A(j){ b=i; } };则下列语句中错误的是（）。
A *pa=new B;

A a1=B(2,9);
B b1(1,2); A *pa1=&b1;
喵查答案：A a1(8); B a2=a1;

24 在下列程序中，C类的数据成员中有一个A类对象和一个B类对象。#include class A { int a; public: A(int x=10) {a=x; } int GetA( ) { return a; } }; class B { int b; public: B(int x) {b=x; } int GetB( ) { return b; } }; class C { int c; A aobj; B bobj; public: C(int x, int y, int z): aobj(y),bobj(z) //E { c=x; } void print( ) { cout<<aobj.GetA()<<'\t'<< bobj.GetB()<<'\t'<<c<<endl ; } }; void main() { C cobj(3,6,8); cobj.print( ); }程序在E行定义了构造函数，如果将该行改为下列中（）选项时，便会出现编译错误。

C(int x, int y, int z): aobj(z),bobj(y)
C(int x, int y, int z): bobj(z)
喵查答案：

C(int x, int y, int z): aobj(y)
C(int x, int y, int z): aobj(z),bobj(y+z)

25 在一个派生类对象结束其生命周期时（）。
喵查答案：

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

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

26 有如下程序：#include class A { public: void func1( ){cout<<"A1";} void func2( ){cout<<"A2";} }; class B:public A { public: void func1( ){cout<<"B1";} void func2( ){cout<func1( ); p->func2( ); }执行该程序，将显示输出( )。
B1B2
喵查答案：A1A2
B1A2
A1B2

27 有如下程序：#include class TestClass { private: char c; public: TestClass (char n):c(n) { } ~TestClass() { cout<<c; } }; class TestClass1:public TestClass { private: char c; public: TestClass1(char n):TestClass (n+1),c(n) { } ~TestClass1() { cout<<c; } }; void main( ) { TestClass1 obj('x'); }执行上面的程序将输出( )。
喵查答案：

xy
yx
x
y

28 下面叙述不正确的是( )。
成员的访问能力在私有派生类中和公有派生类中是不同的
基类的私有成员在公有派生类中不可访问
喵查答案：赋值兼容规则不适用于多重继承的组合
基类公有成员在保护派生中是保护的

29 下面关于多重继承的叙述，正确的是（）。
c++不支持多重继承
多重继承是指从多层基类中派生出的子类
多重继承中派生类成员的访问控制规则与单一继承规则不相同
喵查答案：多重继承中可以通过虚基类防止二义性问题

30 当派生类从基类公有继承时，以下哪种说法是错误的（）。

可以用派生类对象为基类对象赋值。
喵查答案：可以用基类对象为派生类对象赋值。
可以把指向派生类对象的指针赋给基类对象的指针。

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

31 下面有关基类和派生类的说法中，错误的是( )。

派生类可以增添一些基类中没有的成员

32 下面有关派生类的说法中，错误的是( )。

具有继承关系时，基类成员在派生类中的访问权限不变

33 有如下程序：# include using namespace std; class C1 { public: ~C1( ){ cout<<1; } }; class C2: public C1 { public: ~C2( ){ cout<<2; } }; int main( ) { C2 cb2; C1 *cb1; return 0; }运行时的输出结果是( )。

121
喵查答案：21
211
12

34 有如下程序：# include using namespace std; class AA { public: AA( ){ cout<<'1'; } }; class BB: public AA { int k; public: BB( ) : k(0) { cout<<'2'; } BB(int n) : k(n) { cout<<'3'; } }; int main( ) { BB b(4), c; return 0; }运行时的输出结果是( )。
喵查答案：1312
132
32
1412

35 有如下程序，执行后的输出结果应该是（）。#include class BASE{ public: ~BASE(){cout<<"BASE ";} }; class DERIVED: public BASE{ public: ~DERIVED(){cout<<"DERIVED ";} }; void main() { DERIVED x; }
BASE
DERIVED
BASE DERIVED
喵查答案：DERIVED BASE

36 有如下程序，执行后的输出结果应该是（）。#include class A{ public: A(){cout<<"A";} }; class C:public A{ public: C(){cout<<"C";} }; void main() {C cobj;}
喵查答案：AC
CA
A
C

37 有类定义如下：class X { int a; public: X( int x=0 ){ a=x; } }; class Y : public X { int b; public: Y( int x=0, int y=0 ) : X(y) { b=x; } };下列定义对象的语句组中出现语法错误的是（）。

X *pa=new Y(1,2);
X *a1=new X(1);
Y b1(2,3); X &a3=b1;
喵查答案： X a4(10); Y b2=a4;

38 关于多继承二义性的描述中，（）是错的。

一个派生类的两个基类中都有某个同名成员，在派生类中对这个成员的访问可能出现二义性
解决二义性的最常用的方法是对成员名的限定法
喵查答案：

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

40 下面叙述不正确的是（）。
喵查答案：基类的公有成员在派生类中仍然是公有的
派生类一般常用公有派生
对基类成员访问必须是无二义性的
赋值兼容规则也使用于多重继承的组合

41 下面程序的运行结果是（　　）。#include 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";} }; void main() { derived obj; }
喵查答案：0123
3120
312
3012

42 设B类是由A类派生的.当创建一个B类的对象时,构造函数的调用顺序是( )。
喵查答案：先调用A类的构造函数,然后调用B类的构造函数
先调用B类的构造函数,然后调用A类的构造函数
不调用A类的构造函数
视定义时A类和B类出现的位置

43 如果某类是从另一个类继承来的,对象释放时析构函数的调用顺序是( )。
不调用基类的析构函数
先调用基类的析构函数,再调用派生类的析构函数
喵查答案：先调用派生类的析构函数,再调用基类的析构函数
不调用派生类的析构函数

44 有如下程序：#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

45 有如下程序： #include using namespace std; class A { public: A() { cout << "A"; } ~A() { cout << "~A"; } }; class B : public A { A* p; public: B() { cout << "B"; p = new A(); } ~B() { cout << "~B"; delete p; } }; int main() { B obj; return 0; }执行这个程序的输出结果是 ( )
BAA~A~B~A
喵查答案：ABA~B~A~A
BAA~B~A~A
ABA ~A~B~A

46 有如下程序#include using namespace std; class Base{ protected: Base(){ cout << 'A'; } Base(char c){ cout << c; } }; class Derived :public Base{ public: Derived(char c){ cout << c; } }; int main(){ Derived d1('B'); return 0; }执行这个程序，将显示输出（）。
B
BA
喵查答案：AB
BB

47 下面程序的运行结果为（）。#include class A { int num; public: A(int i){num=i;} A(A &a){num=a.num++;} void print(){cout<<num;} }; void main() { A a(1),b(a); a.print(); b.print(); }

11
12
喵查答案：21
22

48 设有以下类的定义：#include class A { protected: int a; public: A(int i=0) { a=i; } int Geta(){ return a; } }; class B: public A { A a1; public: _______________________//B类构造函数的定义 void Show() {cout<<a<<'\t'<<a1.Geta()<<endl; } };则关于B类构造函数，下列定义形式一定不正确的是（）。
可缺省
喵查答案：B(int i=0, int j=0): A(i), a(j){ }
B(int i=0, int j=0): A(i), a1(j){ }
B(int i=0, int j=0): A(i) { }

49 下列程序中，编译时不会出错的语句是（）。#include class Base { public: Base() { } Base(int i) { data=i; } private: int data; }; class Derived: public Base { public: Derived() :Base(0) {} Derived(int x): Base(x) { } }; void main() { Derived d1(1); Base *pb,b1; pb=&d1; //A d1=b1; //B Base &refB=d1; Derived d2=*pb; //C Derived &refD=refB; //D }
喵查答案：A
B
C
D

50 下面（）的叙述不符合赋值兼容规则。
派生类的对象可以赋值给基类的对象
喵查答案：基类的对象可以赋值给派生类的对象
派生类的对象可以初始化基类的引用
派生类的对象的地址可以赋值给指向基类的指针

51 多继承的构造顺序可分为如下4步： ①所有非虚基类的构造函数按照它们被继承的顺序构造； ②所有虚基类的构造函数按照它们被继承的顺序构造； ③所有子对象的构造函数按照它们声明的顺序构造： ④派生类自己的构造函数体：这4个步骤的正确顺序是（）。
④③①②
②④③①
喵查答案：②①③④
③④①②

52 按解释中的要求在下列程序划线处填入的正确语句是：（）#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()；

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

54 解决定义二义性问题的方法有（）。
只能使用作用域分辨运算符
使用作用域分辨运算符或成员名限定
喵查答案：使用作用域分辨运算符或虚基类
使用成员名限定

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

56 有如下程序：#include class Base { public: Base() { cout<<"BB"; f(); } void f(){ cout <<"Bf"; } }; class Derived: public Base { public: Derived(){ cout<<"DD"; } void f(){ cout<<"Df"; } }; void main() { Derived d; }执行上面的程序将输出( )。
喵查答案：BBBfDD
BBDfDDDf
DD
DDBBBf

57 能被派生类继承的函数是( )。
喵查答案：静态成员函数
构造函数
析构函数
复制的构造函数

58 C++中的虚基类机制可以保证（）。

限定基类只通过一条路径派生出派生类
允许基类通过多条路径派生出派生类，派生类也就能多次继承该基类
当一个类多次间接从基类派生以后，派生类对象能保留多份间接基类的成员
喵查答案：

当一个类多次间接从基类派生以后，其基类只被一次继承

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

60 建立包含有类对象成员的派生类对象时，自动调用构造函数的执行顺序依次为（）的构造函数。

自己所属类、对象成员所属类、基类
对象成员所属类、基类、自己所属类
喵查答案：基类、对象成员所属类、自己所属类

基类、自己所属类、对象成员所属类

61 下列关于派生类的构造函数和析构函数中，错误的是（）。

派生类的构造函数会隐含调用基类的构造函数
如果基类中没有默认构造函数，那么派生类必须定义构造函数

在建立派生类对象时，先调用基类的构造函数，再调用派生类的构造函数
喵查答案：在销毁派生类对象时，先调用基类的析构函数，再调用派生类的析构函数

62 带有虚基类的多层派生类构造函数的成员初始化列表中都要列出虚基类构造函数，这样将对虚基类的子对象初始化（）。
与虚基类下面的派生类个数有关
多次
二次
喵查答案：一次

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

派生类的对象可以赋给基类对象
派生类的对象可以初始化基类的引用
喵查答案：派生类的对象可以直接访问基类的成员

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

64 （）可以解决二义性问题。
只能使用作用域分辨操作符
只能使用虚基类
喵查答案：使用作用域分辨操作符或虚基类
其他选项都不能

65 有如下类声明：class XA { private: int x; public: XA(int n){ x=n;} }; class XB: public XA { private: 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){ }

66 下面程序的运行结果为( )。#include class A { public: A(){cout<<""1"";} ~A(){cout<<""2"";} }; class B:public A { public: B(){cout<<""3"";} ~B(){cout<<""4"";} }; void main() { B b; }
1234
1324
喵查答案：1342
3142

67 下列关于this指针的描述中，错误的是（）。
this指针是一个由系统自动生成的指针
this指针是指向对象的
this指针在用对象引用成员函数时系统创建的
喵查答案：this指针只能隐含使用，不能显式使用

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

69 下列关于虚基类的描述中，错误的是( )。
使用虚基类可以消除由多继承产生的二义性
构造派生类对象时，虚基类的构造函数只被调用一次
喵查答案：声明 class B:virtual public A 说明类B为虚基类
建立派生类对象时，首先调用虚基类的构造函数

70 下列关于多继承二义性的描述中，错误的是（）。

一个派生类的多个基类中出现了同名成员时，派生类对同名成员的访问可能出现二义性

一个派生类有多个基类，而这些基类又有一个共同的基类，派生类访问公共基类成员时，可能出现二义性
解决二义性的方法可以采用类名限定
喵查答案：基类和派生类中同时出现同名成员时，会产生二义性

71 下列程序段中具有相同值的是（）。class Base {int b;}; class Base1:virtual public base {int b1;}; class Base2:virtual public base {int b2;}; class derived:publiic base 1,public base2 {int b3;}; derived d;
喵查答案：

d.b与d.base1::b
d.base1::b与 d.base1::b1
d.b与 d.b3
d.base:2:b与 d.base2::b2

72 派生类构造函数的成员初始化列表中，不能包含的初始化项是（）。
基类的构造函数
喵查答案：基类的子对象
派生类的子对象
派生类自身的数据成员

73 多继承派生类构造函数构造对象时，（　　）被最先调用。
派生类自己的构造函数　
喵查答案：虚基类的构造函数
非虚基类的构造函数
派生类中子对象类的构造函数

74 对于下面程序段，表达式正确的是（）。class Base { public: int b; }; class Base1:public base { }; class Base2:public base { }; class Derived:public base1,public base2 {public: int fun ( ); }; Derived d;
喵查答案：

d.Base1::b
d.Base::b
d.b
d.Base::fun( )

75 对于下列程序段，没有二义性的表达式是（）。class A {public: int f(); }; class B {public: int g(); int f(); }; class C:public A,public B {public : int g( ); h( ); }; C obj;

obj.f( )
obj.A::g( )
喵查答案：obj.B::f( )
obj.B::h( )

76 下列声明“A 为虚基类，派生 B类”，正确的是（　　）。
class virtual B : public A
virtual class B: public A
class B : public A virtual
喵查答案：class B : virtual public A

77 下列关于虚基类的描述，错误的是（　　）。

设置虚基类的目的是为了消除二义性
喵查答案：虚基类的构造函数在非虚基类之后调用
若同一层中包含多个虚基类，这些虚基类的构造函数按它们声明的次序调用

若虚基类由非虚基类派生而来，则仍然先调用基类构造函数，再调用派生类的构造函数

78 在派生关系中，（）。
喵查答案：构造函数和释放函数是不能继承的
构造函数可以继承，但释放函数不可以继承
构造函数不可以继承，但释放函数可以继承
构造函数和释放函数都能继承

79 对虚基类的定义（）。
喵查答案：不需要使用虚函数
必须使用虚函数
必须使用private
必须使用public

80 下面叙述不正确的是（）。
派生类一般常用公有派生
对基类成员的访问必须是无二义性的
赋值兼容原则也适用于多重继承的组合
喵查答案：基类的公有成员在派生类中仍然是公有的

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

82 多重继承时，如果派生类的两个父类有一个共同的虚基类，那么虚基类的初始化参数由（）的构造函数来传递。
第一个父类
第二个父类
喵查答案：派生类
以上都不是

83 在创建派生类对象时，构造函数的执行顺序是（）。

对象成员构造函数、基类构造函数、派生类本身的构造函数
派生类本身的构造函数、基类构造函数、对象成员构造函数
基类构造函数、派生类本身的构造函数、对象成员构造函数
喵查答案：

基类构造函数、对象成员构造函数、派生类本身的构造函数

84 解决多继承情况下出现的二义性的方法之一是使用成员名限定法（即类名和作用域运算符）。
喵查答案：正确
错误

85 派生类的构造函数的成员初始化列表中，可以包含基类的子对象初始化。
正确
喵查答案：错误

86 解决多继承情况下出现的二义性的方法之一是使用作用域运算符。
喵查答案：正确
错误

87 虚基类是用来解决多继承中公共基类在派生类中只产生一个基类子对象的问题。
喵查答案：正确
错误

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

89 多重继承情况下，派生类中对基类成员的访问不会出现二义性。
正确
喵查答案：错误

90 在派生类的构造函数的初始化表中不能对包含基类的子对象初始化。
喵查答案：正确
错误

91 多重继承派生类构造函数的成员初始化列表中应包含所有直接基类的构造函数。
正确
喵查答案：错误

92 多重继承的派生类构造函数中执行基类构造函数的顺序取决于该派生类构造函数的成员初始化列表中出现基类初始化项的顺序。
正确
喵查答案：错误

93 多继承情况下，派生类的构造函数的执行顺序取决于定义派生类时所指定的各基类的顺序，而与派生类构造函数中所定义的成员初始化列表的各项顺序无关。
喵查答案：正确
错误

94 C++中设置虚基类的目的是实现运行时的多态。
正确
喵查答案：错误

95 声明为指向基类对象的指针，当其指向派生类对象时，可以利用它来直接访问公有派生类的成员。
正确
喵查答案：错误

96 声明为指向基类对象的指针，当其指向派生类对象时，只能利用它来直接访问派生类中从基类继承来的成员，不能直接访问公有派生类中的成员。
喵查答案：正确
错误

97 不能将一个声明为指向派生类对象的指针指向其基类的对象。
喵查答案：正确
错误

98 可以用一个声明指向基类对象的指针指向它的公有派生的对象。
喵查答案：正确
错误

99 可以用一个声明基类的指针指向它的私有派生的对象。
正确
喵查答案：错误

100 单继承情况下（一级继承）,派生类中对基类成员的访问也会出现二义性。
正确
喵查答案：错误

101 多继承情况下，派生类的构造函数的执行顺序取决于成员初始化列表中的顺序。
正确
喵查答案：错误

第3章多态性（2周）

1 下列是重载乘法运算的函数原型声明，其中错误的是 ( )
喵查答案：myclass operator*(double,double);
myclass operator*(double,myclass);
myclass operator*(myclass,double);
myclass operator*( myclass , myclass);

2 如果定义了一个类myclass，则为myclass类对象以成员函数形式重载后置++运算符的声明应该为（）。
myclass operator++();
myclass &operator++();
喵查答案：myclass operator++(int);
myclass &operator++(int);

3 动态联编所支持的多态性称为（）。
虚函数
继承
编译时的多态性
喵查答案：运行时的多态性

4 在重载一运算符时，若运算符函数的形参表中没有参数，则不可能的情况是（）。
该运算符是一个单目运算符。
该运算符函数有一个隐含的参数this。
该运算符函数是类的成员函数。
喵查答案：该运算符函数是类的友元函数。

5 下面是重载双目运算符-的成员函数原型，其中最符合-原来含义的是（）。
喵查答案：Value Value::operator -(Value);
ValueValue::operator -(int );
Value &Value::operator -(Value);
Value &Value::operator -(Value&);

6 下面是重载双目运算符+的友元函数原型，其中最符合+原来含义的是（）。
喵查答案：Value operator +(Value,Value);
Value operator +(Value,int );
Value &operator +(Value,Value);
Value &operator +(Value&,Value&);

7 假定M是一个类名，且M中重载了操作符=，可以实现M对象间的连续赋值，如“m1=m2=m3;”。重载操作符=的函数原型最好是（）。
int operaotor=(M);
int operator =(M&);
M operator =(M&);
喵查答案：M &operator =(M);

8 假定K是一个类名，并有定义“K k;int j;”，已知K中重载了操作符（），且语句“j=k(3);”和“k(5)=99;”都能顺利执行，说明该操作符函数的原形只可能是（）。

K operator ()(int );

int operator ()(int &);
喵查答案：

int &operator ()(int );
K &operator ()(int );

9 一个程序中数组a和变量k定义为“int a[5][10],k;”，且程序中包含有语句“a(2,5)=++k*3;”，则此语句中肯定属于重载操作符的是（）。
喵查答案：()
=
++
*

10 关于运算符重载，下列说法正确的是（）。
所有的运算符都可以重载
喵查答案：通过重载，可以使运算符应用于自定义的数据类型
通过重载，可以创造原来没有的运算符
通过重载，可以改变运算符的优先级

11 关于运算符重载，下列说法正确的是（）。
重载时，运算符的优先级可以改变。
重载时，运算符的结合性可以改变。
喵查答案：重载时，运算符的功能可以改变。
重载时，运算符的操作数个数可以改变。

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

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

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

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

16 双目运算符重载为普通函数时，其参数表中应带有（）个参数。
0
1
喵查答案：2
3

17 运算符重载时不需要保持的性质是（）。
操作数个数
喵查答案：操作数类型
优先级
结合性

18 下列关于运算符函数的描述中，错误的是( )。
运算符函数的名称总是以operator为前缀
运算符函数的参数可以是对象
喵查答案：运算符函数只能定义为类的成员函数
在表达式中使用重载的运算符相当于调用运算符重载函数

19 将运算符重载为类成员函数时，其参数表中没有参数，说明该运算符是（）。
不合法的运算符
喵查答案：一元运算符
无操作数的运算符
二元运算符

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

21 下列是重载乘法运算的函数原型声明，其中错误的是 ( )
喵查答案：myclass operator*(double,double);
myclass operator*(double,myclass);
myclass operator*(myclass,double);
myclass operator*( myclass , myclass);

22 如果定义了一个类myclass，则为myclass类对象以成员函数形式重载后置++运算符的声明应该为（）。
myclass operator++();
myclass &operator++();
喵查答案：myclass operator++(int);
myclass &operator++(int);

23 动态联编所支持的多态性称为（）。
虚函数
继承
编译时的多态性
喵查答案：运行时的多态性

24 在重载一运算符时，若运算符函数的形参表中没有参数，则不可能的情况是（）。
该运算符是一个单目运算符。
该运算符函数有一个隐含的参数this。
该运算符函数是类的成员函数。
喵查答案：该运算符函数是类的友元函数。

25 下面是重载双目运算符-的成员函数原型，其中最符合-原来含义的是（）。
喵查答案：Value Value::operator -(Value);
ValueValue::operator -(int );
Value &Value::operator -(Value);
Value &Value::operator -(Value&);

26 下面是重载双目运算符+的友元函数原型，其中最符合+原来含义的是（）。
喵查答案：Value operator +(Value,Value);
Value operator +(Value,int );
Value &operator +(Value,Value);
Value &operator +(Value&,Value&);

27 假定M是一个类名，且M中重载了操作符=，可以实现M对象间的连续赋值，如“m1=m2=m3;”。重载操作符=的函数原型最好是（）。
int operaotor=(M);
int operator =(M&);
M operator =(M&);
喵查答案：M &operator =(M);

28 假定K是一个类名，并有定义“K k;int j;”，已知K中重载了操作符（），且语句“j=k(3);”和“k(5)=99;”都能顺利执行，说明该操作符函数的原形只可能是（）。

K operator ()(int );

int operator ()(int &);
喵查答案：

int &operator ()(int );
K &operator ()(int );

29 一个程序中数组a和变量k定义为“int a[5][10],k;”，且程序中包含有语句“a(2,5)=++k*3;”，则此语句中肯定属于重载操作符的是（）。
喵查答案：()
=
++
*

30 关于运算符重载，下列说法正确的是（）。
所有的运算符都可以重载
喵查答案：通过重载，可以使运算符应用于自定义的数据类型
通过重载，可以创造原来没有的运算符
通过重载，可以改变运算符的优先级

31 关于运算符重载，下列说法正确的是（）。
重载时，运算符的优先级可以改变。
重载时，运算符的结合性可以改变。
喵查答案：重载时，运算符的功能可以改变。
重载时，运算符的操作数个数可以改变。

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

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

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

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

36 双目运算符重载为普通函数时，其参数表中应带有（）个参数。
0
1
喵查答案：2
3

37 运算符重载时不需要保持的性质是（）。
操作数个数
喵查答案：操作数类型
优先级
结合性

38 下列关于运算符函数的描述中，错误的是( )。
运算符函数的名称总是以operator为前缀
运算符函数的参数可以是对象
喵查答案：运算符函数只能定义为类的成员函数
在表达式中使用重载的运算符相当于调用运算符重载函数

39 将运算符重载为类成员函数时，其参数表中没有参数，说明该运算符是（）。
不合法的运算符
喵查答案：一元运算符
无操作数的运算符
二元运算符

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

41 在C++中不能被重载的一组运算符是（）。
喵查答案：:: ?: . sizeof
?: . sizeof ++ ->
:: ?: new delete
sizeof ?: ++ —

42 下列关于运算符重载的描述中，（）是正确的。
运算符重载可以改变操作数的个数
运算符重载可以改变优先级
运算符重载可以改变结合性
喵查答案：运算符重载不可以改变语法结构

43 下面关于运算符重载的描述错误的是（　）。

运算符重载不能改变操作数的个数、运算符的优先级、运算符的结合性和运算符的语法结构
不是所有的运算符都可以进行重载
喵查答案：运算符函数的调用必须使用关键字operator

在C++语言中不可通过运算符重载创造出新的运算符

44 下列运算符中，不可以重载的是（）。
++
new
[ ]
喵查答案：?:

45 下列是重载乘法运算符的函数原型声明，其中错误的是（）。
喵查答案：MyClassoperator*(double,double);
MyClassoperator*(double,MyClass);
MyClassoperator*(MyClass,double);
MyClassoperator*(MyClass,MyClass);

46 下列关于运算符重载的叙述中，正确的是（）。
通过运算符重载，可以定义新的运算符
喵查答案：有的运算符只能作为成员函数重载
若重载运算符+，则相应的运算符函数名是+
重载二元运算符时，必须声明两个形参

47 下列关于运算符重载的描述中，错误的是（）。
运算符重载不改变优先级
喵查答案：运算符重载后，原来运算符操作不可再用
运算符重载不改变结合性
运算符重载函数的参数个数与重载方式有关

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

49 在表达式 x+y*z中， + 是作为成员函数重载的运算符，* 是作为非成员函数重载的运算符。则 operator+ 有（）个参数，operator* 有（）参数。
2、2
2、1
喵查答案：1、2
1、1

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

51 在C++的类中以成员函数方式重载双目运算符时，只能指定（）。
喵查答案：一个参数
两个参数
三个参数
不能指定参数

52 下列说法中，正确的说法是（）。
所有的运算符都能被重载
喵查答案：运算符被重载时，它们的优先级与结合性不会改变
当需要时，我们可以自定义一个运算符来进行重载
每个运算符都可以被重载成成员函数和友元函数

53 在成员函数中进行双目运算符重载时，其参数表中应带有（）个参数。
0
喵查答案：1
2
3

54 在重载一个运算符时，其参数表中没有任何参数，这表明该运算符是（）。
作为友元函数重载的1元运算符
喵查答案：作为成员函数重载的1元运算符
作为友元函数重载的2元运算符
作为成员函数重载的2元运算符

55 运算符重载是对已有的运算符赋予多重含义，因此（）。

可以对基本类型（如int类型）的数据，重新定义“+”运算符的含义。
可以改变一个已有运算符的优先级和操作数个数。
喵查答案：只能重载C++中已经有的运算符，不能定义新运算符。

C++中已经有的所有运算符都可以重载。

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

57 有关运算符重载正确的是（）。

C++语言允许在重载运算符时改变运算符的操作个数
C++语言允许在重载运算符时改变运算符的优先级
C++语言允许在重载运算符时改变运算符的结合性
喵查答案：

C++语言允许在重载运算符时改变运算符的原来的功能

58 不能重载的运算符是（　）。
“[ ]” 运算符
喵查答案：“？ : ” 运算符
“( ) ” 运算符
“+” 运算符

59 如果表达式 ++i*k 中的“ ++ ”和“ * ”都是重载的友元运算符，则采用运算符函数调用格式，该表达式还可表示为 ( )。
operator*(i.operator++(),k)
喵查答案：operator*(operator++(i),k)
i.operator++().operator*(k)
k.operator*(operator++(i))

60 假定VOLUME为一个类,在类体中包含如下函数原型:VOLUME operator- (VOLUME c2) const；关于这个函数的叙述中，错误的是（　）。

这是重载运算符-的函数
喵查答案：这个函数所重载的运算符是一个一元运算符
这是一个成员函数

这个函数不改变类的任何数据成员的值

61 下面有关重载的说法中，错误的是 ( )。
函数重载要求同名函数在参数个数或参数类型上不同
运算符重载是用同一个运算符针对不同类型数据进行不同的运算操作
喵查答案：所有的运算符都可以重载
运算符重载函数通常是类的成员函数和友元函数

62 对于复制构造函数和赋值操作的关系，正确的描述是（）。
复制构造函数和赋值操作是完全一样的操作
进行赋值操作时，会调用类的复制构造函数
喵查答案：当调用复制构造函数时，类的对象正在被建立并被初始化
复制构造函数和赋值操作不能在同一个类中被同时定义

63 如果友元函数重载一个运算符时，其参数表中没有任何参数则说明该运算符是( )。
一元运算符
二元运算符
一元和二元运算符都可能
喵查答案：重载错误

64 重载运算符的实质是函数调用,如果重载了后置单目运算符“++”,执行C++,则相当于执行了哪个函数( )。
c.operator++(c,0)
c.operator++( )
operator++()
喵查答案：operator++(c,0)

65 在一个类中可以对一个操作符进行（）重载。
1种
2种以下
3种以下
喵查答案：多种

66 Complex::operator double ( ) { return Real; }上述代码的功能是（）。
喵查答案：将 Complex 类转换成 double 类
将double类转换成Complex类
比较大小
Complex与double相加

67 对于+=（或=）运算符，返回本类对象与返回本类对象的引用：( )。
喵查答案：返回本类对象时初始化临时对象，返回引用不产生临时对象
都没有临时对象产生
都有临时对象产生
都返回对象的引用

68 对于+=（或=）运算符，重载函数的返回值为void类型或本类类型对象的区别是（）。
void类型，本类对象可连续赋值。
喵查答案：本类类型，则本类对象可以连续赋值.
void类型,本类类型都可以连续赋值
void类型,本类类型都不可以连续赋值

69 ::operator++ (int){ … } ，则（）。
喵查答案：int 用于区分后置++运算符
int是参加运算的函数参数
int是前置标志
int什么也不是

70 下列属于动态多态的是( )。
函数重载
运算符重载
喵查答案：虚函数
构造函数重载

71 下列关于多态性说法不正确的是( )。
多态性是指同名函数对应多种不同的实现
多态性表现为重载和覆盖两种方式
喵查答案：重载方式仅有函数重载
重载方式包含函数重载和运算符重载

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

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

74 ( ) 既可重载为一元运算符，又可重载为二元运算符。
喵查答案：*
=
= 和 *
* 和 ++

75 假定要对类AB定义加号操作符重载成员函数，实现两个AB类对象的加法，并返回相加结果，则该成员函数的声明语句为 ( )。
AB operator+(AB &a, AB &)
喵查答案：AB operator+(AB &)
opetacor+(AB a)
AB &operator+( )

76 下列函数中，能重载运算符的函数是( )。
虚函数
构造函数
喵查答案：友元函数
析构函数

77 关于运算符重载，下列表述中正确的是（）。
C++已有的任何运算符都可以重载
运算符函数的返回类型不能声明为基本数据类型
喵查答案：编译系统对重载运算符的选择，遵循函数重载的选择原则
可以通过运算符重载来创建C++中原来没有的运算符

78 有如下的运算符重载函数定义：double operator +(int i , int k) { return double(i+k); }但定义有错误，对这个错误最准确的描述是( )。

+只能作为成员函数重载,而这里的+是作为非成员函数重载的

两个int型参数的和也应该是int型，而这里将+的返回类型声明为double
没有将运算符重载函数声明为某个类的友元
喵查答案：C++已经提供了求两个int型数据之和的运算符+，不能再定义同样的运算符

79 已知在一个类体中包含如下函数原型: VOLUME operator-(VOLUME)const;，下列关于这个函数的叙述中，错误的是（）。

这是运算符-的重载运算符函数
喵查答案：这个函数所重载的运算符是一个一元运算符
这是一个成员函数

这个函数不改变类的任何数据成员的值

80 下列关于运算符重载不正确的是（）。
运算符重载不能改变运算符的操作数个数
运算符重载不能改变运算符的优先级
运算符重载不能改变运算符的结合性
喵查答案：运算符重载能改变对内置类型数据的操作方式

81 下面程序中对一维坐标点类Point进行运算符重载#include using namespace std; class Point{ public: Point(int val){x=val;} Point& operator++(){x++;return *this;} Point operator++(int){Point old=*this;++(*this);return old;} int GetX() const{return x;} private: int x; }; int main() { Point a(10); cout<<(++a).GetX(); cout<<a++.GetX(); return 0; }编译和运行情况是( )。

运行时输出1011
喵查答案：运行时输出1111
运行时输出1112
编译有错

82 重载赋值操作符时，应声明为（）函数。
友元
虚
喵查答案：成员
多态

83 运算符重载函数的形参不允许有默认值。因为形参对应参加运算的的实际的运算量，运算时运算量是不能缺省的。
喵查答案：正确
错误

84 运算符的重载可以改变原来的含义，可臆造新的运算符。
正确
喵查答案：错误

85 如果用户未显式定义赋值运算符重载函数，编译器会自动生成一个，完成数据成员的简单赋值。
喵查答案：正确
错误

86 可以利用运算符重载实现用运算符直接对字符串对象进行加、减等操作。
喵查答案：正确
错误

87 对一般的二元运算符重载为友元函数比重载为成员函数更优越。
喵查答案：正确
错误

88 当用友元函数实现运算符的重载时，重载函数的参数个数只能是1 个或 2 个。
喵查答案：正确
错误

89 为myclass类对象以成员函数形式重载前置++运算符的声明应该为myclass operator++(int);
正确
喵查答案：错误

90 运算符重载的形式有两种:成员函数形式和友元形式。
喵查答案：正确
错误

91 运算符重载实际上是对已有的运算符重新定义其功能。
喵查答案：正确
错误

92 重载的运算符保持原来的优先级和结合性以及操作数的个数。
喵查答案：正确
错误

93 对每个可重载的运算符来说,只能重载为友元函数。
正确
喵查答案：错误

94 重载运算符保持原运算符的优先级和结合性不变。
喵查答案：正确
错误

95 对每个可重载的运算符来讲，它既可以重载为友元函数，又可以重载为成员函数，还可以重载为非成员函数。
正确
喵查答案：错误

96 多数运算符可以重载，个别运算符不能重载，运算符重载是通过函数定义实现的。
喵查答案：正确
错误

97 函数的参数个数和类型都相同，只是返回值不同，这不是重载函数。
喵查答案：正确
错误

98 函数重载是一种多态现象，它属于动态联编。
正确
喵查答案：错误

99 在C++中对于运算符重载，只能重载已有的运算符。
喵查答案：正确
错误

100 动态联编是在运行时选定所要调用的成员函数的。
喵查答案：正确
错误

101 重载运算符可改变原运算符的优先级和结合性。
正确
喵查答案：错误

102 运算符重载后，原运算符的优先级和结合特性会改变。
正确
喵查答案：错误

103 重载运算符的函数也可以设置默认参数。
正确
喵查答案：错误

104 运算符重载是通过函数来实现的，定义运算符重载函数时，函数名中要使用关键字operator
喵查答案：正确
错误

105 运算符重载是通过对已有的运算符重新定义操作功能来实现的，它是C++语言多态性的一种表现。
喵查答案：正确
错误

106 运算符重载后，原运算符的优先级和结合特性不会改变。
喵查答案：正确
错误

107 运算符重载后，优先级、结合性和操作数都是不变的。
喵查答案：正确
错误

108 所有的运算符都可以重载。
正确
喵查答案：错误

109 使用成员函数方法和使用友元函数的方法所定义的重载运算符函数的参数个数是不相同的。
喵查答案：正确
错误

1 关于抽象类，下列表述正确的是（）。
抽象类的成员函数中至少有一个没有实现的函数（即无函数体定义的函数）
派生类必须实现作为基类的抽象类中的纯虚函数
派生类不可能成为抽象类
喵查答案：抽象类不能用于定义对象

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

3 对于类定义class A{ public: virtual void funcl(){} void func2(){} }; class B:public A{ public: void func1(){cout<<”class Bfunc1”<<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()是虚函数

4 通过一个基类类型的（　）调用虚函数时，采用动态绑定。
派生类名　
对象
成员名限定
喵查答案：指针

5 凡是能用以派生新类，却不能创建自己的对象的类称为（）。
虚基类
喵查答案：抽象类
容器类
派生类

6 通过一个对象调用虚函数时，C++系统对该调用采用（）。
动态联编
喵查答案：静态联编
不确定是哪种联编
函数重载

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

8 关于纯虚函数和抽象类的描述中，（）是错误的。

纯虚函数是一种特殊的虚函数，它没有具体的实现
抽象类是指具有纯虚函数的类
喵查答案：一个基类说明有纯虚函数，该基类的派生类一定不再是抽象类

抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出

9 关于虚函数的描述中，（）是正确的。
虚函数是一个static类型的成员函数
虚函数是一个非成员函数
喵查答案：基类中说明了虚函数后，派生类中将其对应的函数可不必说明为虚函数
派生类的虚函数与基类的虚函数具有不同的参数个数和类型

10 对虚函数的调用（）。
一定使用动态联编
一定使用静态联编
必须使用动态联编
喵查答案：不一定使用动态联编

11 运行时的多态性是通过（）实现的。
构造函数
析构函数
喵查答案：虚函数
函数重载

12 抽象类指的是（）。
没有任何成员的类
只有成员函数没有数据成员的类
有虚函数的类
喵查答案：有纯虚函数的类

13 若一个类中含有纯虚函数，则该类称为（）。
基类
纯基类
派生类
喵查答案：抽象类

14 对虚函数不正确描述是（）。

虚函数的作用是允许在派生类中重新定义与基类同名的函数
虚函数只能用于类的成员函数，但不能用于类的构造函数和类的静态成员函数
派生类的虚函数与基类的同名虚函数具有相同的参数个数和类型
喵查答案：不可以声明虚析构函数

15 在派生类中，重载一个虚函数时，要求函数名、参数的个数、参数的类型、参数的顺序和函数的返回值（）。
不同
喵查答案：相同
相容
部分相同

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

17 下列关于虚函数的说明中，正确的是（）。
从虚基类继承的函数都是虚函数。
喵查答案：虚函数不得是静态成员函数。
只能通过指针和引用调用虚函数。
抽象类中的成员函数都是虚函数。

18 下列关于虚函数的描述中，错误的是（）。
虚函数是一个成员函数
虚函数具有继承性
喵查答案：静态成员函数可以说明为虚函数
在类的继承的层次结构中，虚函数是说明相同的函数

19 下列关于动态联编的描述中，错误的是（）。

动态联编是函数联编的一种方式，它是在运行时来选择联编函数的
动态联编又可称为动态多态性，它是C++语言中多态性的一种重要形式
喵查答案：函数重载和运算符重载都属于动态联编

动态联编只是用来选择虚函数的

20 下列关于抽象类的描述中，错误的是（）。
抽象类中至少应该有一个纯虚函数
抽象类可以定义对象指针和对象引用
抽象类通常用作类族中最顶层的类
喵查答案：抽象类的成员函数至少有一个没实现（即无函数体定义的函数）

21 关于抽象类，下列表述正确的是（）。
抽象类的成员函数中至少有一个没有实现的函数（即无函数体定义的函数）
派生类必须实现作为基类的抽象类中的纯虚函数
派生类不可能成为抽象类
喵查答案：抽象类不能用于定义对象

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

23 对于类定义class A{ public: virtual void funcl(){} void func2(){} }; class B:public A{ public: void func1(){cout<<”class Bfunc1”<<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()是虚函数

24 通过一个基类类型的（　）调用虚函数时，采用动态绑定。
派生类名　
对象
成员名限定
喵查答案：指针

25 凡是能用以派生新类，却不能创建自己的对象的类称为（）。
虚基类
喵查答案：抽象类
容器类
派生类

26 通过一个对象调用虚函数时，C++系统对该调用采用（）。
动态联编
喵查答案：静态联编
不确定是哪种联编
函数重载

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

28 关于纯虚函数和抽象类的描述中，（）是错误的。

抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出

29 关于虚函数的描述中，（）是正确的。
虚函数是一个static类型的成员函数
虚函数是一个非成员函数
喵查答案：基类中说明了虚函数后，派生类中将其对应的函数可不必说明为虚函数
派生类的虚函数与基类的虚函数具有不同的参数个数和类型

30 对虚函数的调用（）。
一定使用动态联编
一定使用静态联编
必须使用动态联编
喵查答案：不一定使用动态联编

31 运行时的多态性是通过（）实现的。
构造函数
析构函数
喵查答案：虚函数
函数重载

32 抽象类指的是（）。
没有任何成员的类
只有成员函数没有数据成员的类
有虚函数的类
喵查答案：有纯虚函数的类

33 若一个类中含有纯虚函数，则该类称为（）。
基类
纯基类
派生类
喵查答案：抽象类

34 对虚函数不正确描述是（）。

35 在派生类中，重载一个虚函数时，要求函数名、参数的个数、参数的类型、参数的顺序和函数的返回值（）。
不同
喵查答案：相同
相容
部分相同

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

37 下列关于虚函数的说明中，正确的是（）。
从虚基类继承的函数都是虚函数。
喵查答案：虚函数不得是静态成员函数。
只能通过指针和引用调用虚函数。
抽象类中的成员函数都是虚函数。

38 下列关于虚函数的描述中，错误的是（）。
虚函数是一个成员函数
虚函数具有继承性
喵查答案：静态成员函数可以说明为虚函数
在类的继承的层次结构中，虚函数是说明相同的函数

39 下列关于动态联编的描述中，错误的是（）。

动态联编只是用来选择虚函数的

40 下列关于抽象类的描述中，错误的是（）。
抽象类中至少应该有一个纯虚函数
抽象类可以定义对象指针和对象引用
抽象类通常用作类族中最顶层的类
喵查答案：抽象类的成员函数至少有一个没实现（即无函数体定义的函数）

41 下列各种类中，不能定义对象的类是（）。
派生类
喵查答案：抽象类
嵌套类
虚基类

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

43 若要强制C++对虚函数的调用使用静态联编，则在调用中对该函数使用（）。
喵查答案：成员名限定
指针
引用
VIRTUAL关键字

44 若派生类中没有对基类的虚函数进行重定义，则它继承基类中的（）。
访问权限
保护成员
喵查答案：虚函数
成员函数

45 类定义如下：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( )是虚函数

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

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

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

47 关于虚函数，正确的描述是（）。
喵查答案：构造函数不能是虚函数　　　　
析构函数不能是虚函数
虚函数可以是友元函数
虚函数可以是静态成员函数

48 关于虚函数，下列表述正确的是（）。
如果在重定义虚函数时使用virtual，则该重定义函数仍然是虚函数
喵查答案：虚函数不得声明为静态函数
虚函数不得声明为另一个类的友元函数
派生类必须重新定义基类的虚函数

49 关于函数的描述中，( )是正确的。
派生类的虚函数与基类的虚函数具有不同的参数个数和类型
基类中说明了虚函数后，派生类中其对应的函数一定要说明为虚函数
喵查答案：虚函数是一个成员函数
虚函数是一个static类型的成员函数

50 关于动态联编的下列叙述中，( )是错误的。
动态联编是以虚函数为基础的
动态联编调用虚函数操作是指向对象的指针或引用
动态联编是在运行时确定所调用的函数代码的
喵查答案：动态联编是在编译时确定操作函数的

51 关于纯虚函数，下列表述中正确的是（）。
喵查答案：纯虚函数的声明总是以”=0″结束
含有纯虚函数的类可以定义对象
含有纯虚函数的类不一定是抽象类
上面都是错误的

52 关于纯虚函数，下列表述正确的是（）。
纯虚函数是给出实现版本（即无函数体定义）的虚函数
喵查答案：纯虚函数的声明总是“=0”结束
派生类必须实现基类的纯虚函数
含有纯虚函数的类一定是派生类

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

54 在下面程序中，编译时出现的错误是( )。class A //file:(1) { public: //file:(2) A() { func(); //file:(3) } virtual void func()=0; //file: (4) };

（1）
（2）
喵查答案：（3）
（4）

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

56 用于类中虚成员函数说明的关键字（）。
喵查答案：virtual
public
protected
private

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

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

59 虚函数的定义是在基类中进行的，定义时需要冠以关键字（　　）。
static
friend
喵查答案：virtual
public

60 编译时的多态性通常使用（）获得。
继承
虚函数
喵查答案：重载函数
析构函数

61 编译时的多态性可以通过使用（　　）获得。
虚函数和指针
重载函数和析构函数
喵查答案：虚函数和对象
虚函数和引用

62 若析构函数是虚函数，则delete对析构函数的调用采用（）。
静态联编
喵查答案：动态联编
重载函数
多重函数

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

64 下列描述错误的是（）。
喵查答案：在创建对象前,静态成员不存在
静态成员是类的成员
静态成员不能是虚函数
静态成员函数不能直接访问非静态成员

65 有如下程序：#include class A { public: virtual void func1( ){cout<<"A1";} void func2( ){cout<<"A2";} }; class B:public A { public: void func1( ){cout<<"B1";} void func2( ){cout<func1( ); p->func2( ); }执行该程序，屏幕上将显示输出( )。
B1B2
A1A2
喵查答案：B1A2
A1B2

66 下列关于多态性的描述，错误的是（）。
C++语言中的多态性分为编译时的多态性和运行时的多态性
编译时的多态性可通过函数重载实现
喵查答案：运行时的多态性可通过模板和虚函数实现
实现运行时多态性的机制称为动态绑定

67 分析下面的程序，正确的输出结果是（）。 #include #include using namespace std; class base { public: virtual char *fun(void)const=0; }; char *base::fun(void)const { return "base"; } class derived1:virtual public base { public: char *fun(void)const { return "derived1"; } }; class derived2:virtual public base { public: char *fun(void)const { return "derived2"; } }; class subderived:public derived1,public derived2 { public: char *fun(void)const { char *pch; pch=new char[strlen(derived1::fun()) + strlen(derived2::fun()) + 1]; strcpy(pch, derived1::fun()); strcat(pch, derived2::fun()); return pch; } }; void main(void) { base *pb; pb=new derived1; cout<fun()<<endl; pb=new derived2; cout<fun()<<endl; pb=new subderived; cout<fun()<<endl; }
basebasebase
喵查答案：derived1derived2derived1derived2
derived1derived1derived1derived2
derived2derived2derived1derived2

68 有如下程序，没有使用多态机制#include using 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<show(); return 0; }运行后输出的结果是( )。
喵查答案：10,20
30,40
20,30
50,50

69 派生类的虚函数必须与基类虚函数同名，且参数表完全相同，如果不同则（）。
喵查答案：属于函数重载
是虚函数
是虚函数和函数重载
是普通函数

70 下面的描述中，正确的是（）。
喵查答案：

virtual可以用来声明虚函数
含有纯虚函数的类是不可以用来创建对象的，因为它是虚基类
即使基类的构造函数没有参数，派生类也必须建立构造函数

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

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

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

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

72 #include class A { public: virtual void vfun(void){ cout<<"A_vfun ";} }; class B : public A { public: void vfun(void){ cout<vfun(); pA=new B; pA->vfun(); } 程序编译链接运行结果为（）。
A_vfun A_vfun
B_vfun B_vfun
A_vfun B_vfun
喵查答案：编译出错

73 假设A为抽象类，下列声明（）是正确的。
A fun(int);
喵查答案：A *p;
int fun(A);
A Obj;

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

75 有如下程序： #include #include using namespace std; class Publication{ //出版物类 char name[30]; public: Publication(char *name="未知名称") { strcpy(this->name,name); } const char * getName()const{ return name; } virtual const char * getType()const{ return "未知类型";} }; class Book: public Publication{ //书类 public: Book(char *name): Publication(name){} virtual const char * getType()const{ return "书";} }; void showPublication( Publication &p){ cout<<p.getType()<<": "<<p.getName()<<endl; } int main(){ Book book("精彩人生"); showPublication(book); return 0; }运行时的输出结果是( )。
未知类型：未知名称
未知类型：精彩人生
书：未知名称
喵查答案：

书：精彩人生

76 在派生类中重新定义虚函数时，必须在下列哪方面与基类保持一致？（）
喵查答案：参数类型
参数名字
操作内容
赋值

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

所有的运算符都可以重载。
基类类型的指针可以指向子类，子类类型的指针也可以指向基类。
可以在类的构造函数中对静态数据成员进行初始化。
喵查答案：

动态联编要满足两个条件：被调用的成员函数是虚函数；用基类指针或引用调用虚函数。

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

79 有如下程序：#include using namespace std; class TestClass { public: virtual void fun1( ) { cout<<"fun1TestClass"<<endl; } virtual void fun2( ) { cout<<"fun2TestClass"<<endl; } }; class TestClass1:public TestClass { void fun1( ) { cout<<"fun1TestClass1"<<endl; } void fun2(int x) { cout<<"fun2TestClass1"<fun1(); p->fun2(); return 0; }该程序执行后的输出结果是( )。
喵查答案：fun1TestClass1fun2TestClass
fun1TestClass1fun2TestClass1
fun1TestClassfun2TestClass
fun1TestClassfun2TestClass1

80 下面正确的说法是( )。
关键字virtual只能用来声明虚函数
声明虚函数时，才使用关键字virtual
关键字virtual不能用来声明虚基类
喵查答案：关键字virtual能用来声明虚基类

81 下列函数中，不能说明为虚函数的是( )。
私有成员函数
公有成员函数
喵查答案：构造函数
析构函数

82 下面是关于虚析构函数的说法，其中不正确的是（）。
虚析构函数也必须遵守调用层次惟一的原则
虚析构函数被调用时，只有成员函数的本地版本被调用
可以创建一个纯虚析构函数
喵查答案：虚析构函数可以带参数

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

84 要实现动态联编，派生类中的虚函数（）。
返回的类型可以与虚函数的原型不同
参数个数可以与虚函数的原型不同
参数类型可以与虚函数的原型不同
喵查答案：以上都不对

85 有如下程序：#include class BASE{ char c; public: BASE(char n) : c(n){} virtual ~BASE(){ cout << c; } }; class DERIVED:public BASE{ char c; public: DERIVED(char n) : BASE(n + 1), c(n){} ~DERIVED(){ cout << c; } }; int main() { DERIVED D('X'); return 0; }执行上面的程序将输出（）。
喵查答案：XY
YX
X
Y

86 有如下程序：#include using 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<f(); p->g(); return 0; }运行时输出的结果是( )。
f+g+
f0+g+
喵查答案：f+g0+
f0+g0+

87 纯虚函数与函数体为空的虚函数等价。
正确
喵查答案：错误

88 对于从基类继承的虚函数，派生类也可以不进行重定义。
喵查答案：正确
错误

89 虚函数不能是类的静态成员函数。
喵查答案：正确
错误

90 如果派生类的成员函数的原型与基类中被定义为虚函数的成员函数原型相同，那么，这个函数自动继承基类中虚函数的特性。
喵查答案：正确
错误

91 构造函数可以声明为虚函数。
正确
喵查答案：错误

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

93 抽象类是指一些没有说明对象的类。
正确
喵查答案：错误

94 析构函数说明为虚函数是没有意义的。
正确
喵查答案：错误

95 抽象类是一些不能实例化的类，即不能定义对象的类。
喵查答案：正确
错误

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

97 只有类的成员函数才能声明为虚函数。
喵查答案：正确
错误

98 只要是成员函数就可以说明为虚函数，因为虚函数是一种成员函数。
正确
喵查答案：错误

99 一个抽象类中可以包含有多个纯虚函数，一个派生类中也可以包含多个虚函数。
喵查答案：正确
错误

100 虚函数在基类和派生类之间定义，且要求函数原型完全一致。
喵查答案：正确
错误

101 虚函数有继承性，基类中说明的虚函数只要在它的派生类中函数原型完全一致，一定是虚函数。
喵查答案：正确
错误

102 虚函数是实现动态联编的必要条件。
喵查答案：正确
错误

103 运行时的多态（动态多态）是通过类的继承和虚函数来实现的。
喵查答案：正确
错误

104 实现通过基类的指针或引用撤消派生类对象时的多态性，析构函数应该定义为虚函数。
喵查答案：正确
错误

105 构造函数调用虚函数，调用的是类本身的虚函数。
喵查答案：正确
错误

106 抽象类只能作基类，不能定义抽象类的对象。
喵查答案：正确
错误

107 不能将构造函数定义为虚函数。
喵查答案：正确
错误

108 具有纯虚函数的类是抽象类,它的特点是不可以定义对象。
喵查答案：正确
错误

109 纯虚函数是一种特殊的成员函数,它是一种没有具体实现的虚函数。
喵查答案：正确
错误

110 构造函数说明为纯虚函数是没有意义的.
喵查答案：正确
错误

111 对于从基类继承的虚函数，派生类也可以不进行重定义。
喵查答案：正确
错误

112 作为虚函数隐含参数的this指针，决定了虚函数调用时执行的代码。
喵查答案：正确
错误

113 虚函数可以被类的对象调用，也可以被类的对象指针和对象引用调用。
喵查答案：正确
错误

114 析构函数可以说明为虚函数，而构造函数说明为虚函数没有意义。
喵查答案：正确
错误

115 静态成员函数也能声明为虚函数。
正确
喵查答案：错误

116 静态联编和动态联编都是在编译时进行的，二者的区别仅是前者对非虚函数，后者对虚函数。
正确
喵查答案：错误

117 含有纯虚函数的类称为抽象类，与抽象类相对应的是具体类。
喵查答案：正确
错误

118 动态联编指的是在运行期间来选择不同类的虚函数。
喵查答案：正确
错误

119 抽象类可以用来直接创建对象。
正确
喵查答案：错误

120 抽象类可以定义对象，不可以定义对象指针和对象引用。
正确
喵查答案：错误

121 抽象类的派生类一定是具体类。
正确
喵查答案：错误

122 不可以定义抽象类的对象。
喵查答案：正确
错误

123 C++不允许将构造函数、析构函数和虚函数声明为友元函数。
喵查答案：正确
错误

关注工众号

喵查

查看更多答案

第1章 面向对象程序设计（4周）

第2章 继承性（2周）

第3章 多态性（2周）

第1章面向对象程序设计（4周）

第2章继承性（2周）

第3章多态性（2周）