大学MOOC 面向对象的C++和Windows编程(武汉理工大学)1002463008 最新慕课完整章节测试答案

第1章1.1+1.2测验

1、单选题：
‍所谓数据封装就是将一组数据和与这组数据有关操作组装在一起，形成一个封装体，这个封装体就是（  ）。‍
选项：
A: 类
B: 对象  
C: 函数体
D: 数据块
答案: 【 类】

2、单选题：
‎为了使类中的某个成员不能被类的对象通过成员操作符访问，则不能把该成员的访问权限定义为（　　）。‎
选项：
A: public
B: protected
C: private 
D: static
答案: 【 public】

3、单选题：
‌下列程序中说明的公有成员是(   ).‌class Location{
int X;
public:
  void init(int,init X,int init Y);
private:
int Y;
public:
  int GetX();
  int GetY();
};‌‌
选项：
A: X
B: init(int,init X,int init Y)
C: GetX(),GetY()
D: init(int init X,int init Y),GetX(),GetY()都是
答案: 【 init(int init X,int init Y),GetX(),GetY()都是】

4、单选题：
‏下列关于成员函数的描述中，错误的是（   ）。 ‏
选项：
A: 成员函数的定义必须在类体外 
B: 成员函数可以是公有的，也可以是私有的
C: 成员函数在类体外定义时，前加inline可为内联函数 
D: 成员函数可以设置参数的默认值 
答案: 【 成员函数的定义必须在类体外 】

5、单选题：
‌下列关于创建一个int型变量的引用，正确的是（   ）。‎
选项：
A: int a(3),&ra=a; 
B: int a(3),&ra=&a; 
C: double d(3.1);int &rd=d; 
D: int a(3),ra=a; 
答案: 【 int a(3),&ra=a; 】

6、单选题：
​p是指向类A数据成员x的指针，a是类A的一个对象。在给x成员赋值为5的下列表达式中，正确的是（   ）。 ‏
选项：
A: a.p=5 
B: a->p=5 
C: a.*p=5 
D: *a.p=5 
答案: 【 a.*p=5 】

7、单选题：
‎下列关于对象的描述中，错误的是（   ）。‎
选项：
A: 对象是类的一个实例
B: 对象是属性和行为的封装体
C: 对象就是C语言中的结构变量
D: 对象是现实世界中客观存在的某种实体
答案: 【 对象就是C语言中的结构变量】

8、单选题：
​下列关于对象的描述中，错误的是（   ）。‎
选项：
A: 定义对象时系统会自动进行初始化 
B: 对象成员的表示与C语言中结构变量的成员表示相同 
C: 属于同一个类的对象占有内存字节数相同 
D: 一个类所能创建对象的个数是有限制的 
答案: 【 一个类所能创建对象的个数是有限制的 】

9、单选题：
‏下列关于类的描述中，错误的是（   ）。‍
选项：
A: 类就是C语言中的结构类型
B: 类是创建对象的模板
C: 类是一种抽象数据类型
D: 类是具有共同行为的若干对象的统一描述体
答案: 【 类就是C语言中的结构类型】

10、单选题：
‍下列关于类的权限的描述错误的是（      ）‍
选项：
A: 类本身的成员函数只能访问自身的私有成员
B: 类的对象只能访问该类的公有成员
C: 普通函数不能直接访问类的公有成员，必须通过对象访问
D: 一个类可以将另一个类的对象作为成员
答案: 【 类本身的成员函数只能访问自身的私有成员】

11、单选题：
‎下列关于类和对象的叙述中，错误的是（   ）。‌
选项：
A: 一个类只能有一个对象       
B: 对象是类的具体实例 
C: 类是对某一类对象的抽象
D: 类和对象的关系是一种数据类型与变量的关系
答案: 【 一个类只能有一个对象       】

12、单选题：
​下列关于面向对象概念的描述中，错误的是（   ）。​
选项：
A: 面向对象方法比面向过程方法更加先进
B: 面向对象方法中使用了一些面向过程方法中没有的概念
C: 面向对象方法替代了结构化程序设计方法
D: 面向对象程序设计方法要使用面向对象的程序设计语言
答案: 【 面向对象方法替代了结构化程序设计方法】

13、单选题：
​下列关于设置函数默认的参数值的描述中，错误的是（   ）。‏
选项：
A: 可对函数的部分参数或全部参数设置默认值
B: 在有函数说明时，默认值应设置在函数说明时，而不是定义时
C: 设置函数参数默认值应从左向右设置
D: 设置函数参数默认值应从右向左设置
答案: 【 设置函数参数默认值应从左向右设置】

14、单选题：
​下列关于引用概念的描述中，错误的是（   ）。‎
选项：
A: 引用是变量，它具有值和地址值
B: 引用不可以作数组元素
C: 引用是变量的别名
D: 创建引用时必须进行初始化
答案: 【 引用是变量，它具有值和地址值】

15、单选题：
‎下列哪个不是面向对象的特征（      ）‏
选项：
A: 抽象性
B: 结构性
C: 封装性
D: 多态性
答案: 【 结构性】

16、单选题：
‎下列设置函数参数默认值的说明语句中，错误的是（   ）。其中，a和b是已定义过具有有效值的变量。​
选项：
A: int fun(int x , int y=10); 
B: int fun(int x=5, int =10); 
C: int fun(int x=5, int y); 
D: int fun(int x , int y=a+b); 
答案: 【 int fun(int x=5, int y); 】

17、单选题：
‌下列说法正确的是（   ）‎
选项：
A: 类定义中只能说明函数成员的函数头，不能定义函数体
B: 类中的函数成员可以在类体内定义,也可以在类体外定义
C: 类中的函数成员在类体外定义时必须要与类声明在同一文件中
D: 在类体外定义的函数成员不能操作该类的私有数据成员
答案: 【 类中的函数成员可以在类体内定义,也可以在类体外定义】

18、单选题：
‎void Set( &a);是类中一个成员函数的说明，其中&a的含义是（   ）。 ‏
选项：
A: 类A的对象引用a作该函数的参数 
B: 类A的对象a的地址值作函数的参数
C: 表达式变量A与变量a按位与作函数参数 
D: 指向类A对象指针a作函数参数 
答案: 【 类A的对象引用a作该函数的参数 】

19、单选题：
‌下列选择重载函数的不同实现的判断条件中，错误的是（   ）。‌
选项：
A: 参数类型不同 
B: 参数个数不同
C: 参数顺序不同 
D: 函数返回值不同
答案: 【 函数返回值不同】

20、单选题：
‏下面（　　）是函数重载。​
选项：
A: void play(int) 和void play(float)
B: play( ) 和 ~play()
C: void play(int) 和int play(int)
D: void play( ) 和int play( )
答案: 【 void play(int) 和void play(float)】

21、单选题：
‍在函数的引用调用中，函数的实参和形参分别应是（   ）。‍
选项：
A: 变量值和变量 
B: 地址值和指针
C: 变量名和引用 
D: 地址值和引用
答案: 【 变量名和引用 】

22、单选题：
​在类外定义类的成员函数时，应当使用（　　）来标识该函数为特定类的成员。​
选项：
A:  ：  
B:  ：：
C: -> 
D: this
答案: 【  ：：】

23、单选题：
‌假定AA为一个类，a()为该类公有的函数成员，x为该类的一个对象，则访问x对象中函数成员a()的格式为（   ）。​
选项：
A: x.a
B: x.a()
C: x->a
D: x->a()
答案: 【 x.a()】

24、单选题：
‌假定AA为一个类，a为该类公有的数据成员，px为指向该类对象的一个指针，则访问px所指对象中数据成员a的格式为（  ）。​
选项：
A: px(a)
B: px[a]
C: px->a
D: px.a
答案: 【 px->a】

25、单选题：
​假定AA为一个类，a为该类私有的数据成员，GetValue()为该类公有函数成员，它返回a的值，x为该类的一个对象，则访问x对象中数据成员a的格式为（   ）。‏
选项：
A: x.a
B: x.a()
C: x->GetValue()
D: x.GetValue()
答案: 【 x.GetValue()】

26、单选题：
‌假定AA为一个类，int a()为该类的一个成员函数，若该成员函数在类定义体外定义，则函数头为（）。‍
选项：
A: int AA::a()
B: int AA:a()
C: AA::a()
D: AA::int a()
答案: 【 int AA::a()】

27、单选题：
​关于成员函数特征的下述描述中，（   ）是错误的。‎
选项：
A: 成员函数一定是内联函数
B: 成员函数可以重载
C: 成员函数可以设置参数的缺省值
D: 成员函数可以是静态的
答案: 【 成员函数一定是内联函数】

28、单选题：
‏已知类A中的一个成员函数的说明如下:void Set(A &a);则该函数的参数"A &a"的含义是（   ）​
选项：
A: 指向A的指针为a
B: 将变量a的地址赋给类A
C: 类A对象引用a用作函数的形参
D: 变量A与a按位与后作函数参数
答案: 【 类A对象引用a用作函数的形参】

29、单选题：
​在类定义的外部，可以被访问的成员有（   ）‌
选项：
A: 所有类成员
B: private或protected的类成员
C: public的类成员
D: public或private的类成员
答案: 【 public的类成员】

30、单选题：
​关于封装，下列说法中不正确的是（   ）。‌
选项：
A: 通过封装，对象的全部属性和操作结合在一起，形成一个整体
B: 通过封装，一个对象的实现细节被尽可能地隐藏起来（不可见）
C: 通过封装，每个对象都成为相对独立的实体
D: 通过封装，对象的属性都是不可见的
答案: 【 通过封装，对象的属性都是不可见的】

31、单选题：
‌下面关于对象概念的描述中，（   ）是错误的。​
选项：
A: 对象就是C语言中的结构变量
B: 对象代表着正在创建的系统中的一个实体
C: 对象是一个状态和操作（或方法）的封装体
D: 对象之间的信息传递是通过消息进行的
答案: 【 对象就是C语言中的结构变量】

32、单选题：
​下面关于类概念的描述中，（   ）是错误的。‌
选项：
A: 类是抽象数据类型的实现
B: 类是具有共同行为的若干对象的统一描述体
C: 类是创建对象的样板
D: 类就是C语言中的结构类型
答案: 【 类就是C语言中的结构类型】

33、单选题：
‎关于对象和类的关系，说法不正确的是（   ）。‍
选项：
A: 同属于一类的对象，具有相同的数据成员和成员函数
B:  对象是具体，是类的对象，同其他变量一样，先定义后使用
C:  同一类的不同对象，其具有的操作可不同，具体的操作也不同
D: 不同类的对象，可有相同的操作
答案: 【  同一类的不同对象，其具有的操作可不同，具体的操作也不同】

34、单选题：
‍类的实例化是指（　　）‍
选项：
A: 创建类对象  
B: 定义类
C: 调用类的成员
D: 指明具体的类
答案: 【 创建类对象  】

35、单选题：
‎类的私有成员可在何处被访问(     )‏
选项：
A: 本类的成员函数中    
B: 本类及子类的成员函数中
C: 通过对象名在任何位置
D: 不可访问
答案: 【 本类的成员函数中    】

36、单选题：
‎（   ）是不可以作为该类的成员的。‍
选项：
A: 自身类对象的指针
B: 自身类的对象
C: 自身类对象的引用
D: 另一个类的对象
答案: 【 自身类的对象】

37、单选题：
‌     下述程序中语句完全不正确的一组语句是（）‏‌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.";   //⑧
    ｝‏
选项：
A: ①、②、③、④、⑤ 
B:  ①、②、③、⑤、⑥
C: ②、③、④、⑤、⑥ 
D:  ①、②、④、⑦、⑧
答案: 【  ①、②、③、⑤、⑥】

38、单选题：
‎设有以下类和对象的定义:‍class A
{public:
int k;
};
A x1,x2,*p1,*p2;‎则下面针对成员变量k的引用，正确的是（  ）。‍
选项：
A: x1->k=1;
B: x2.k=2; 
C:  p1.k=3;
D: (*p2)->k=4; 
答案: 【 x2.k=2; 】

39、单选题：
‏设有以下类的定义：‏class Ex
{ int x;
 public:
void setx(int t=0);
};‏若在类外定义成员函数setx(),以下定义形式中正确的是（ ）。‏
选项：
A: void setx(int t) {…}
B: void Ex::setx(int t) {…}
C: Ex::void setx(int t) {…}
D: void Ex::setx(){…}
答案: 【 void Ex::setx(int t) {…}】

40、单选题：
​有如下类声明： ‍class TestClass
{
      int i;
private:
      int j;    
protected:
      int k;
public:
      int m,n;
};​其中，私有成员的数量为(   )‍
选项：
A: 0
B: 1
C: 2
D: 3
答案: 【 2】

41、单选题：
​在C++中，一个函数为void  f(int, char ch='a')，另一个函数void  f(int)，则它们（        ）。‏
选项：
A:  不能在同一程序中定义 
B: 可以在同一程序中定义并可重载
C: 可以在同一程序中定义，但不可以重载
D: 其他三种说法均不正确
答案: 【 可以在同一程序中定义并可重载】

42、单选题：
‌关于类的成员函数，下列说法正确的是（     ）。‍
选项：
A: 必须在类体内定义
B: 一定是内联函数
C: 不可以重载
D: 可以设置参数的缺省值
答案: 【 可以设置参数的缺省值】

43、判断题：
‎C++语言支持封装性和继承性，不支持多态性。‍
选项：
A: 正确
B: 错误
答案: 【 错误】

44、判断题：
‏成员函数与一般函数一样可以重载、内联和设置参数的默认值。 ‎
选项：
A: 正确
B: 错误
答案: 【 正确】

45、判断题：
​定义对象引用时，可以对其引用进行初始化，也可以不进行初始化。 ‍
选项：
A: 正确
B: 错误
答案: 【 错误】

46、判断题：
‌定义一个对象时，系统只为该对象的数据成员开辟内存空间，而成员函数是同类对象共享的。 ‌
选项：
A: 正确
B: 错误
答案: 【 正确】

47、判断题：
‏定义在类体内的成员函数是内联函数，定义在类体外的成员函数不能是内联函数。 ​
选项：
A: 正确
B: 错误
答案: 【 错误】

48、判断题：
‍类的公有成员函数是类与外界的接口。   ‌
选项：
A: 正确
B: 错误
答案: 【 正确】

49、判断题：
‏类中的成员函数都是公有的，数据成员都是私有的。 ‏
选项：
A: 正确
B: 错误
答案: 【 错误】

50、判断题：
‏类中的数据成员不能为指针类型。                 ‍
选项：
A: 正确
B: 错误
答案: 【 错误】

51、判断题：
​使用class定义的类，其默认的访问权限是公有的，使用struct定义的类，其默认的访问权限是私有的。 ‌
选项：
A: 正确
B: 错误
答案: 【 错误】

52、判断题：
‎一个类只能有一个对象。  ‏
选项：
A: 正确
B: 错误
答案: 【 错误】

53、判断题：
​已知：类A中一个成员函数说明如下：void  Set(A&a)；其中A &a的含意是将a的地址给变量Set。‍
选项：
A: 正确
B: 错误
答案: 【 错误】

54、判断题：
‎已知:m是类A的对象,n是类A的公有数据成员,p是指向类A中n成员的指针.下述两种表示是等价的：m.n和m.*p​
选项：
A: 正确
B: 错误
答案: 【 正确】

55、判断题：
‌对象引用作为函数参数比用对象指针更方便些.​
选项：
A: 正确
B: 错误
答案: 【 正确】

56、判断题：
​在C++中，定义函数时必须给出函数的返回类型。​
选项：
A: 正确
B: 错误
答案: 【 正确】

57、判断题：
‌自身类对象的引用不可以作为该类的成员。‏
选项：
A: 正确
B: 错误
答案: 【 错误】

58、判断题：
‍函数的参数个数和类型都相同,只是返回值不同,这不是重载函数.‍
选项：
A: 正确
B: 错误
答案: 【 正确】

59、判断题：
‎使用内联函数是以增大空间开销为代价的.‌
选项：
A: 正确
B: 错误
答案: 【 正确】

60、判断题：
‌在类的定义中，必须包含private、public、protected三种存取方式对应的部分。    ‎
选项：
A: 正确
B: 错误
答案: 【 错误】

61、判断题：
‍在用class定义一个类时,数椐成员和成员函数默认的访问权限是public。​
选项：
A: 正确
B: 错误
答案: 【 错误】

62、判断题：
‏面向对象方法具有封装性、继承性和多态性。‌
选项：
A: 正确
B: 错误
答案: 【 正确】

63、判断题：
‏类的私有成员只能被类中的成员函数访问，任何类以外的函数对它们的访问都是非法的。‍
选项：
A: 正确
B: 错误
答案: 【 错误】

64、判断题：
‌重载函数可以带默认值参数,但要注意二义性.‎
选项：
A: 正确
B: 错误
答案: 【 正确】

第1章1.3+1.4测验

1、单选题：
‍假定一个类的构造函数为B(int x,int y){a=x--;b=a*y--;},则执行B x(3,5); 语句后，x.a和x.b的值分别为（  ）‍
选项：
A: 3和5
B: 5和3
C: 3和15
D: 20和5
答案: 【 3和15】

2、单选题：
‎（   ）是析构函数的特征。‏
选项：
A: 析构函数可以有一个或多个参数
B: 析构函数定义只能在类体内
C: 析构函数名与类名不同
D: 一个类中只能定义一个析构函数
答案: 【 一个类中只能定义一个析构函数】

3、单选题：
‌下列(   )不是构造函数的特征‌
选项：
A: 构造函数的函数名与类名相同
B: 构造函数可以重载
C: 构造函数可以设置默认参数
D: 构造函数必须指定类型说明
答案: 【 构造函数必须指定类型说明】

4、单选题：
‎下列关于C++类的描述中错误的是（  ）。‏
选项：
A: 类与类之间可以通过一些手段进行通信和联络
B: 类用于描述事物的属性和对事物的操作
C: 类与类之间必须是平等的关系，而不能组成层次关系
D: 类与类之间可以通过封装而具有明确的独立性
答案: 【 类与类之间必须是平等的关系，而不能组成层次关系】

5、单选题：
‏下列关于构造函数的描述中，错误的是（   ）。 ‎
选项：
A: 构造函数可以设置默认的参数
B: 构造函数在定义类对象的自动执行 
C: 构造函数可以是内联函数
D: 构造函数不可以重载
答案: 【 构造函数不可以重载】

6、单选题：
‎下面的哪一个构造函数头格式不正确（　　）。　　‎
选项：
A:  AA(int a,int b)　
B:  AA(int a,int b＝0)
C: AA(int a＝0,int b＝0)
D:  AA(int a＝0,int b)
答案: 【  AA(int a＝0,int b)】

7、单选题：
‌下列关于析构函数的描述中，错误的是（   ）。 ​
选项：
A: 析构函数的函数体都为空 
B: 析构函数是用来释放对象的
C: 析构函数是系统自动调用的 
D: 析构函数是不能重载的
答案: 【 析构函数的函数体都为空 】

8、单选题：
‎下列关于析构函数描述正确的是(     )‏
选项：
A: 可以重载    
B: 函数体中必须有delete语句
C: 返回类型必须是void类型    
D: 不能指定返回类型   
答案: 【 不能指定返回类型   】

9、单选题：
​下列关于子对象(内嵌对象成员)的描述中，错误的是（   ）。 ‌
选项：
A: 子对象不可以是自身类的对象
B: 子对象是另一个类的对象
C: 子对象的初始化要包含在构造函数中
D: 一个类中只能有一个子对象 
答案: 【 一个类中只能有一个子对象 】

10、单选题：
‌下面（　　）项是对构造函数和析构函数的正确定义。‎
选项：
A: void X::X(),   void X::~X()
B: X::X(参数),    X::~X()
C: X::X(参数),    X::~X(参数)
D: void X::X(参数),  void X::~X(参数)
答案: 【 X::X(参数),    X::~X()】

11、单选题：
‏下面说法中正确的是（   ）‌
选项：
A: 一个类只能定义一个构造函数，但可以定义多个析构函数
B: 一个类只能定义一个析构函数，但可以定义多个构造函数
C: 构造函数与析构函数同名，只是名字前加了一个求反符号（~）
D: 构造函数可以指定返回类型，而析构函数不能指定任何返回类型，即使是void类型也不可以
答案: 【 一个类只能定义一个析构函数，但可以定义多个构造函数】

12、单选题：
‌下面有关构造函数的描述中，正确的是（  ）。‎
选项：
A: 构造函数可以带有返回值
B: 构造函数的名字与类名完全相同
C: 构造函数必须带有参数 
D: 构造函数必须定义，不能缺省
答案: 【 构造函数的名字与类名完全相同】

13、单选题：
​形如X::X(X&)的构造函数称为(     )‎
选项：
A: 拷贝函数     
B: 复制函数 
C: 初始化函数
D: 复制构造函数
答案: 【 复制构造函数】

14、单选题：
‏一个类可包含析构函数的个数是（      ）‌
选项：
A: 多个
B: 1个
C: 至少一个
D: 0个或多个
答案: 【 1个】

15、单选题：
‍一个类拥有多个构造函数，则这些构造函数间为（      ）‎
选项：
A: 重载关系
B: 重复关系
C: 拷贝关系
D: 无关系
答案: 【 重载关系】

16、单选题：
​定义析构函数时，正确的是（　　） 。 ‎
选项：
A: 其名与类名完全相同 　
B: 无形参，也没有返回值 
C: 返回类型是 void 类型
D: 函数体中必须有 delete 语句 
答案: 【 无形参，也没有返回值 】

17、单选题：
‌一个类中一个无参数构造函数和一个全部都是默认参数的构造函数共存是否存在二义性（      ）‎
选项：
A: 存在
B: 不存在
C: 无法确定    
D: 视构造函数的参数来确定
答案: 【 存在】

18、单选题：
​已知X类.则当程序执行到语句‏​X  array[3];‏​时,调用了(   )次构造函数.‏
选项：
A: 0
B: 1
C: 2
D: 3
答案: 【 3】

19、单选题：
​已知AA是一个类，则执行语句AA a;后（     ）​
选项：
A: 自动调用无参构造函数
B: 自动调用有参构造函数
C: 自动调用拷贝构造函数
D: 产生一个对象a,但不调用任何函数
答案: 【 自动调用无参构造函数】

20、单选题：
​已知example是已定义的类,则程序结束前,共存在(      )个对象.‏#include<iostream.h>
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();
}​‏
选项：
A: 2
B: 3
C: 4
D: 5
答案: 【 3】

21、单选题：
‍在下列函数原型中，可以作为类AA构造函数的是（   ）。‏
选项：
A: void AA(int);   
B: int AA();   
C: AA(int)const;   
D: AA(int);
答案: 【 AA(int);】

22、单选题：
‍执行下列说明语句，其调用构造函数的次数为（  ）。‎‍A a[5]，*p[2];‎‍其中，A是一个类名 ‎
选项：
A: 5
B: 6
C: 7
D: 8
答案: 【 5】

23、单选题：
​下列对类的构造函数和析构函数的叙述，正确的是（   ）​
选项：
A: 构造函数可以重载，析构函数不能重载
B: 构造函数不能重载，析构函数可以重载
C: 构造函数可以重载，析构函数也可以重载
D: 构造函数不能重载，析构函数也不能重载
答案: 【 构造函数可以重载，析构函数不能重载】

24、单选题：
​对于复制构造函数point::point(point& p)，下列说明正确的是（      ）‍
选项：
A: 该函数只能访问P的私有成员
B: 该函数不能访问P的公有成员
C: 该函数可以访问P的私有和公有成员
D: 该函数不能访问P的成员
答案: 【 该函数可以访问P的私有和公有成员】

25、单选题：
​一个类的析构函数是在（   ）时被自动调用。​
选项：
A: 使用该类对象前 
B: 使用该类对象后 
C: 该类对象撤消 
D: 定义该类对象
答案: 【 该类对象撤消 】

26、单选题：
‍下列关于对象数组的描述中，（   ）是错误的。‎
选项：
A: 对象数组的下标是从0开始的
B: 对象数组的数组名是一个常量指针
C: 对象数组的每个元素是同一个类的对象
D: 对象数组只能赋初值，而不能被赋值
答案: 【 对象数组只能赋初值，而不能被赋值】

27、单选题：
​复制构造函数的作用是（   ）‎
选项：
A: 进行数据类型的转换
B: 用对象调用成员函数
C: 用对象初始化对象
D: 用一般类型的数据初始化对象
答案: 【 用对象初始化对象】

28、单选题：
‍在C++中，当一个对象被创建后，它的每一个成员函数都含有一个系统自动生成的隐含的指针，称之为（   ）指针。‎
选项：
A: 对象
B: 派生
C: 基类
D: this
答案: 【 this】

29、单选题：
‌一个类的构造函数通常被定义为该类的（   ）成员。‎
选项：
A: 公有
B: 保护
C: 私有
D: 友元
答案: 【 公有】

30、单选题：
​一个类的析构函数通常被定义为该类的（   ）成员。‏
选项：
A: 私有
B: 保护
C: 公有
D: 友元
答案: 【 公有】

31、单选题：
‏假定AB 为一个类，则执行“AB x;”语句时将自动调用该类的（   ）。‌
选项：
A: 带参构造函数
B: 无参构造函数
C: 拷贝构造函数
D: 赋值重载函数
答案: 【 无参构造函数】

32、单选题：
‍假定AB  为一个类，则执行“AB  x(a,5);”语句时将自动调用该类的（   ）。‍
选项：
A: 带参构造函数
B: 无参构造函数
C: 拷贝构造函数
D: 赋值重载函数
答案: 【 带参构造函数】

33、单选题：
​假定AB  为一个类，则执行“AB  r1=r2;”语句时将自动调用该类的（   ）。‍
选项：
A: 无参构造函数
B: 带参构造函数
C: 赋值重载函数
D: 拷贝构造函数
答案: 【 拷贝构造函数】

34、单选题：
‎假定一个类的构造函数为 “A(int aa, int bb) {a=aa; b=aa*bb;}”，则执行 “A  x(4,5);”语句后，x.a和x.b的值分别为（   ）。‏
选项：
A: 4和5
B: 5和4
C: 4和20
D: 20和5
答案: 【 4和20】

35、单选题：
‌假定一个类的构造函数为 “A(int aa=1, int bb=0) {a=aa; b=bb;}”，则执行 “A x(4);”语句后，x.a和x.b的值分别为（   ）。‌
选项：
A: 1和0
B: 1和4
C: 4和1
D: 4和0
答案: 【 4和0】

36、单选题：
‎假定AB 为一个类，则（   ）为该类的复制构造函数的原型说明。‏
选项：
A: AB (AB x);
B: AB (AB &x);
C: void AB (AB &x);
D: AB (int x);
答案: 【 AB (AB &x);】

37、单选题：
‎假定一个类的构造函数为 “B(int ax, int bx): a(ax), b(bx) {}”，执行 “B x(1,2),y(3,4);x=y;”语句序列后x.a的值为。‏
选项：
A: 1
B: 2
C: 3
D: 4
答案: 【 3】

38、单选题：
‍假定一个类AB 只含有一个整型数据成员a，当用户不定义任何构造函数时，系统为该类定义的无参构造函数为（ ）。‎
选项：
A: AB (){a=0;}
B: AB (int aa=0):a(aa){}
C: AB (int aa):a(aa){}
D: AB (){}
答案: 【 AB (){}】

39、单选题：
‍假定一个类AB 只含有一个整型数据成员a，用户为该类定义的带参构造函数可以为（   ）。‎
选项：
A: AB (){}
B: AB ():a(0){}
C: AB (int aa=0){a=aa;}
D: AB (int aa){}
答案: 【 AB (int aa=0){a=aa;}】

40、单选题：
‎假定一个类对象数组为A[n]，当离开它定义的作用域时，系统自动调用该类析构函数的次数为（   ）。‏
选项：
A: 0
B: 1
C: n
D: n-1
答案: 【 n】

41、单选题：
‍假定AB  为一个类，则执行“AB  a(2),b[3],*p[4];”语句时共调用该类构造函数的次数为（   ）。‎
选项：
A: 3
B: 4
C: 5
D: 9
答案: 【 4】

42、单选题：
‌假定AB  为一个类，则执行“AB  a,b(3),*p;”语句时共调用该类构造函数的次数为（   ）。‍
选项：
A: 2
B: 3
C: 4
D: 5
答案: 【 2】

43、单选题：
‌假定AB  为一个类，则执行“AB  a,b(2),c[3],*p=&a;”语句时共调用该类无参构造函数的次数为（   ）。‏
选项：
A: 5
B: 6
C: 3
D: 4
答案: 【 4】

44、单选题：
‎对类对象成员的初始化是通过构造函数中给出的（   ）实现的。‎
选项：
A: 函数体
B: 初始化表
C: 参数表
D: 初始化表或函数体
答案: 【 初始化表】

45、单选题：
​下列函数中，（      ）不能重载。‍
选项：
A: 成员函数
B: 非成员函数
C: 析构函数
D: 构造函数
答案: 【 析构函数 】

46、单选题：
‎关于对象成员的构造函数的调用顺序，说法正确的是(   )。​
选项：
A: 与他们在成员初始化列表中给出的顺序相同
B: 与折构函数的调用顺序相同
C: 与他们在类中说明顺序相同
D: 以上说法都不对
答案: 【 与他们在类中说明顺序相同】

47、单选题：
‎关于下面程度段说法正确的是(   ).‎class X
{
private:
  int n;
punblic:
  X(X&);
}
X::X(X&x)
{n=x.n}
X obj1,obj2;
obj2(obj1);‎‎
选项：
A: 语句obj2（obj1）；的功能是用对象obj1初始化具有相同类类型的对象obj2  
B: 语句obj2（obj1）；的功能是用对象obj2初始化具有相同类类型的对象obj1
C: X(X&x)也可以不使用引用参数而仍然是拷贝构造函数
D: X(X&x)不能访问对象的私有成员
答案: 【 语句obj2（obj1）；的功能是用对象obj1初始化具有相同类类型的对象obj2   】

48、单选题：
‏假定A 为一个类,则执行A  x;语句时将自动调用该类的(  ) ‌
选项：
A: 有参构造函数           
B: 无参构造函数
C: 拷贝构造函数 
D: 赋值构造函数
答案: 【 无参构造函数】

49、单选题：
‍假定AB为一个类，则(     )为该类的复制构造函数的原型说明。‏
选项：
A: AB(AB x);         
B: AB(int x); 
C: AB(AB& x);  
D: void AB(AB& x);
答案: 【 AB(AB& x);  】

50、单选题：
‌假定AB为一个类，则执行 “AB r1=r2;” 语句时将自动调用该类的（　　）。‏
选项：
A: 无参构造函数    
B: 带参构造函数
C: 赋值重载函数
D: 复制构造函数
答案: 【 复制构造函数】

51、单选题：
‌假定MyCIass为一个类，那么下列的函数说明中，（   ）为该类的析构函数。‎
选项：
A: void~MyClass();
B: ~MyClass(intn);
C: MyClass();
D: ~MyClass();
答案: 【 ~MyClass();】

52、单选题：
​假定Mylass为一个类，则该类的复制构造函数的声明语句为（      ） ‎
选项：
A: MyClass&(MyClass x)；
B: MyClass(MyClass x)；
C: MyClass(MyClass &x)；
D: MyClass(MyClass *x)；
答案: 【 MyClass(MyClass &x)；】

53、单选题：
​复制构造函数的参数通常是（   ）。‎
选项：
A: 无特殊要求
B: 指向对象的指针
C: 自已类对象的引用
D: 对象
答案: 【 自已类对象的引用】

54、单选题：
‍复制构造函数具有的下列特点中，（　　）是错误的。‌
选项：
A: 如果一个类中没有定义复制构造函数时，系统将自动生成一个默认的
B: 复制构造函数只有一个参数，并且是该类对象的引用
C: 复制构造函数是一种成员函数
D: 复制构造函数的名字不能用类名
答案: 【 复制构造函数的名字不能用类名】

55、单选题：
‍类AB的缺省构造函数和析构函数是（　　）‍
选项：
A: AB( )和~AB( )                    
B: AB(int)和~AB( )  
C: AB( )和~AB(delete ) 
D: AB( )和int~AB( )
答案: 【 AB( )和~AB( )                     】

56、单选题：
‏类的构造函数的作用是（　　）‍
选项：
A: 一般成员函数  
B: 类的初始化
C:  对象的初始化
D: 删除对象
答案: 【  对象的初始化 】

57、单选题：
​类的析构函数的作用是（　　） ‍
选项：
A: 一般成员函数的初始化 
B: 类的初始化
C: 对象的初始化 
D: 删除类创建的对象
答案: 【 删除类创建的对象】

58、单选题：
‍缺省析构函数的函数体是（   ）‌
选项：
A: 不存在
B: 随机产生的
C: 空的
D: 无法确定的
答案: 【 空的】

59、单选题：
‍如果没有为一个类定义任何构造函数的情况下，下列描述正确的是（      ）‎
选项：
A: 编译器总是自动创建一个不带参数的构造函数
B: 这个类没有构造函数
C: 这个类不需要构造函数
D: 该类不能通过编译
答案: 【 编译器总是自动创建一个不带参数的构造函数 】

60、单选题：
​设类A将其它类对象作为成员，则建立A类对象时，下列描述正确的是（      ）‌
选项：
A: A类构造函数先执行
B: 成员构造函数先执行
C: 两者并行执行
D: 不能确定
答案: 【 成员构造函数先执行 】

61、单选题：
‍假定AA是一个类，“AA& abc();”是该类中一个成员函数的原型，若该函数存在对*this赋值的语句，当用x.abc()调用该成员函数后，x的值（   ）。‌
选项：
A: 已经被改变   
B: 可能被改变
C: 不变
D: 不受函数调用的影响
答案: 【 已经被改变    】

62、单选题：
‍有如下程序：‍# include <iostream>
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;
}‍运行此程序输出符号?的个数是（   ）。‍
选项：
A: 0
B: 1
C: 2
D: 3
答案: 【 3】

63、单选题：
‏有如下两个类定义：‌class AA{};
class BB 
{
      AA v1,*v2;
      BB v3;
      int *v4;
};‏其中有一个成员变量的定义是错误的，这个变量是(      )。‌
选项：
A: v1
B: v2
C: v3
D: v4
答案: 【 v3】

64、单选题：
‌在C++中，编译系统自动为一个类生成缺省构造函数的条件是（ ）。‌
选项：
A: 该类没有定义任何有参构造函数
B: 该类没有定义任何无参构造函数
C: 该类没有定义任何构造函数
D: 该类没有定义任何成员函数
答案: 【 该类没有定义任何构造函数】

65、单选题：
​下面类的定义，有（ ）处错误。​class MyClass{
private:
int i=0;
public:
void MyClass();
~MyClass(int Value);
};​​
选项：
A: 1
B: 2
C: 3
D: 4
答案: 【 3】

66、单选题：
‍已知：p是一个指向类A数据成员m的指针，A1是类A的一个对象。如果要给m赋值为5，正确的是（   ）​
选项：
A: A1.p=5;
B: A1->p=5;
C: A1.*p=5;
D: *A1.p=5;
答案: 【 A1.*p=5; 】

67、单选题：
‏类的构造函数被自动调用执行的情况是在定义该类的（   ）‏
选项：
A: 成员函数时
B: 数据成员时
C: 对象时
D: 友元函数时
答案: 【 对象时】

68、单选题：
‎若Sample类中的一个成员函数说明如下：void set(Sample& a)，则Sample& a的含义是（   ）‏
选项：
A: 指向类Sample的名为a的指针
B: a是类Sample的对象引用，用来作函数Set()的形参
C: 将a的地址赋给变量Set
D: 变量Sample与a按位与的结果作为函数Set的参数
答案: 【 a是类Sample的对象引用，用来作函数Set()的形参】

69、单选题：
‎假定有类AB，有相应的构造函数定义，能正确执行 “AB a(4),b(5), c[3] , *p[2]={&a,&b}；”语句，请问执行完此语句后共调用该类析构函数的次数为（   ）‎
选项：
A: 3
B: 4
C: 5
D: 6
答案: 【 5】

70、单选题：
‍对于复制构造函数，正确的描述是（   ）。   ‎
选项：
A: 在C++语言中，如果不自定义类的复制构造函数，则每个类都有默认的复制构造函数 
B: 必须为每个类定义复制构造函数
C: 如果要使用复制构造函数，则必须在类中先定义
D: 当定义了类的构造函数时，如果要使用复制构造函数，则必须定义复制构造函数
答案: 【 在C++语言中，如果不自定义类的复制构造函数，则每个类都有默认的复制构造函数 】

71、单选题：
‎有如下程序：‍#include<iostream>
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;
}‎运行时的输出结果是（  ）‍
选项：
A: 3
B: 23
C: 123
D: 213
答案: 【 123】

72、单选题：
‍下面表述错误的是（     ）。 ​
选项：
A: this指针是字符指针
B: this指针是当前指针
C: this指针是隐含指针
D: this指针是特殊指针
答案: 【 this指针是字符指针 】

73、单选题：
‏C++如果某函数的返回值是个对象，则该函数被调用时，返回的对象（）‍
选项：
A: 是通过复制构造函数初始化的
B: 是通过无参数的构造函数初始化的
C: 用哪个构造函数初始化取决于函数中 return 语句是怎么写的
D: 不需要初始化
答案: 【 是通过复制构造函数初始化的 】

74、单选题：
‎下列程序的运行结果为‍#include<iostream.h>
int i=0;
class A{
public:
     A(){i++;}
};
void main()
{
    A a;
    A b[3],*c;
    c=b;
    cout<<i<<endl;
}‎‍
选项：
A: 2
B: 3
C: 4
D: 5
答案: 【 4】

75、单选题：
​有如下程序：‌#include<iostream>
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;
}​运行时的输出结果是(   )。‌
选项：
A: 3
B: 3 destructor
C: copy constructor
D: constructor
答案: 【 3 destructor】

76、单选题：
‍ 若有如下类声明​   class MyClass{
   public:
           MyClass(){cout<<1;}
};‍执行下列语句​‍MyClass a,b[2],*p[2];​‍以后，程序的输出结果是(    )​
选项：
A: 11
B: 111
C: 1111
D: 11111
答案: 【 111】

77、单选题：
‏复数类及对象的定义如下：‌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‏下述说法中正确的是（      ）。‌
选项：
A: C行和D行均调用了拷贝构造函数
B: C行调用了拷贝构造函数
C: B行调用了拷贝构造函数
D: A行调用了拷贝构造函数
答案: 【 C行调用了拷贝构造函数】

78、单选题：
​下列描述中，（      ）不是构造函数的特征。 ​
选项：
A: 构造函数可以重载
B: 必须显式的为类定义一个构造函数
C: 无需为构造函数指定返回值类型
D: 构造函数在产生对象时由系统自动调用
答案: 【 必须显式的为类定义一个构造函数】

79、单选题：
​下列有关析构函数的描述中，正确的是（      ）。‌
选项：
A: 析构函数的定义只能在类体内
B: 析构函数可以有一个或多个参数
C: 析构函数在撤消对象时，系统自动调用
D: 析构函数可以重载
答案: 【 析构函数在撤消对象时，系统自动调用】

80、单选题：
#include <iostream.h>
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( );
}​对上述程序段，下述说法中正确的是（     ）。​
选项：
A: 在编译时报错，程序无法运行
B: 编译无错，运行正常，输出3，5
C: 编译无错，运行时报错
D: 编译时报警告错，但运行正常，输出3，5
答案: 【 在编译时报错，程序无法运行 】

81、单选题：
​有如下程序：‎#include<iostream> 
using namespace std;
class Test{
public:
Test(){} 
~Test(){cout<<'#';}
};
int main(){
Test  temp[2], *pTemp[2]; 
return 0;
}​执行这个程序输出星号（#）的个数为（     ）。‎
选项：
A: 1
B: 2
C: 3
D: 4
答案: 【 2】

82、单选题：
‍类TM和类TN是两个独立的类，那么类TM中哪种形式的数据成员一定是不允许的：(   )​
选项：
A: TM * a;    
B: TN & a; 
C: TM a; 
D: TN a;
答案: 【 TM a; 】

83、单选题：
对于如下的类（）   ‍class  Animal
   ｛    float weight;
         int   feet;
       public:
         Animal(float w, int f＝4)
        ｛  weight=w;
            feet=f;
         ｝
    ｝;‍  定义其对象完全正确的一组语句是（）‍
选项：
A: Animal  a1(3.6, 8); Animal  a2;
B: Animal  a1(3.6, 8); Animal  a2(67.9);  
C: Animal  a1(67.9); Animal  a2; 
D: Animal  a1(3.6, 8); Animal  a2();
答案: 【 Animal  a1(3.6, 8); Animal  a2(67.9);  】

84、单选题：
已知一个类Complex，有下述两行：‏   Complex c;              //A‏   Complex c();             //B‏以下描述中，错误的是（      ）。‏
选项：
A: A行定义了一个对象，并调用缺省构造函数
B: B行定义了一个对象，并调用缺省构造函数
C: B行是一个函数原型说明，函数名为c，函数没有参数，返回值类型为Complex
D: A和B行的意义不一样
答案: 【 B行定义了一个对象，并调用缺省构造函数】

85、单选题：
设有定义：‌class person
{ int num;
  char name[10];
public:
  void init(int n, char *m);
  ...
};
person std[30];‌则以下叙述不正确的是(     )。‌
选项：
A: std是一个含有30个元素的对象数组
B: std数组中的每一个元素都是person类的对象
C: std数组中的每一个元素都有自己的私有变量num和name
D: std数组中的每一个元素都有各自的成员函数init
答案: 【 std数组中的每一个元素都有各自的成员函数init】

86、判断题：
‍this指针是系统生成的指向当前被某个成员函数操作对象的指针。‍
选项：
A: 正确
B: 错误
答案: 【 正确】

87、判断题：
‎创建对象时系统自动调用相应的构造函数为对象初始化，没有相应的构造函数时，系统会自动生成。‎
选项：
A: 正确
B: 错误
答案: 【 正确】

88、判断题：
‍定义对象指针时也要调用构造函数。​
选项：
A: 正确
B: 错误
答案: 【 错误】

89、判断题：
‎定义或说明对象时，系统会自动调用构造函数为创建的对象初始化。如果类中没有定义任何构造函数时，就无法给定义的对象初始化。 ‏
选项：
A: 正确
B: 错误
答案: 【 错误】

90、判断题：
‍对象引用可以用一个同类对象的地址值对它赋值。​
选项：
A: 正确
B: 错误
答案: 【 错误】

91、判断题：
​对象指针成员表示与对象引用相同。 ​
选项：
A: 正确
B: 错误
答案: 【 错误】

92、判断题：
‏对象指针可用同类对象的地址值给它赋值。​
选项：
A: 正确
B: 错误
答案: 【 正确】

93、判断题：
‍对象指针数组可以使用不同类的对象的地址值进行初始化。‍
选项：
A: 正确
B: 错误
答案: 【 正确】

94、判断题：
‍给对象数组元素赋值时都要创建临时对象。‍
选项：
A: 正确
B: 错误
答案: 【 错误】

95、判断题：
‍构造函数的功能是对对象进行初始化。‍
选项：
A: 正确
B: 错误
答案: 【 正确】

96、判断题：
‎构造函数和析构函数都可以重载，因为它们都是成员函数。‍
选项：
A: 正确
B: 错误
答案: 【 错误】

97、判断题：
‌构造函数和析构函数都可以重载。‌
选项：
A: 正确
B: 错误
答案: 【 错误】

98、判断题：
‌构造函数和析构函数都是系统自动调用的成员函数。‏
选项：
A: 正确
B: 错误
答案: 【 正确】

99、判断题：
‌构造函数可以设置默认参数。‌
选项：
A: 正确
B: 错误
答案: 【 正确】

100、判断题：
‎构造函数没有函数返回类型。  ‍
选项：
A: 正确
B: 错误
答案: 【 正确】

101、判断题：
​构造函数是一个其名与类名相同的特殊的成员函数。‏
选项：
A: 正确
B: 错误
答案: 【 正确】

102、判断题：
‌假定AB为一个类，则执行“AB a[10];”语句时，系统自动调用该类的构造函数的次数为1次。​
选项：
A: 正确
B: 错误
答案: 【 错误】

103、判断题：
‏复制构造函数用它所在类的对象作为参数。‌
选项：
A: 正确
B: 错误
答案: 【 错误】

104、判断题：
‎类的析构函数的作用是对象的初始化。‍
选项：
A: 正确
B: 错误
答案: 【 错误】

105、判断题：
‍析构函数不指定参数，而构造函数可以指定参数。‌
选项：
A: 正确
B: 错误
答案: 【 正确】

106、判断题：
‏析构函数可以有形参。  ‌
选项：
A: 正确
B: 错误
答案: 【 错误】

107、判断题：
‌析构函数是一个函数体为空的成员函数。‏
选项：
A: 正确
B: 错误
答案: 【 错误】

108、判断题：
‍一个类中只能定义一个析构函数。 ‎
选项：
A: 正确
B: 错误
答案: 【 正确】

109、判断题：
‌在程序中可以显式调用构造函数。 ​
选项：
A: 正确
B: 错误
答案: 【 正确】

110、判断题：
‍指向对象的常指针的地址值是可以改变的。‏
选项：
A: 正确
B: 错误
答案: 【 错误】

111、判断题：
​子对象的初始化要在构造函数的成员初始化列表中进行。‌
选项：
A: 正确
B: 错误
答案: 【 正确】

112、判断题：
‎自身类对象可作该类的子对象。‎
选项：
A: 正确
B: 错误
答案: 【 错误】

113、判断题：
‏构造函数和析构函数都不能重载。‍
选项：
A: 正确
B: 错误
答案: 【 错误】

114、判断题：
‌对象数组的元素可以是不同类的对象.‎
选项：
A: 正确
B: 错误
答案: 【 错误】

115、判断题：
​指向对象数组的指针不一定必须指向数组的首元素.‍
选项：
A: 正确
B: 错误
答案: 【 正确】

116、判断题：
‌一维对象指针数组的每个元素应该是某个类的对象的地址值.‍
选项：
A: 正确
B: 错误
答案: 【 正确】

117、判断题：
‏this指针是一个指向正在被某个成员函数操作的对象的指针。‏
选项：
A: 正确
B: 错误
答案: 【 正确】

118、判断题：
‌通常的复制构造函数的参数是某个对象的指针名。​
选项：
A: 正确
B: 错误
答案: 【 错误】

119、判断题：
‌复制构造函数的参数可以是某类的对象名。​
选项：
A: 正确
B: 错误
答案: 【 错误】

120、判断题：
‎如果在类声明中没有定义复制构造函数，就不能用一个对象去初始化另一个对象。​
选项：
A: 正确
B: 错误
答案: 【 错误】

121、判断题：
‏如果程序中未声明构造函数，则系统自动产生出一个默认形式的构造函数。​
选项：
A: 正确
B: 错误
答案: 【 正确】

122、判断题：
‎如果程序中未声明析构函数，编译器将自动产生一个默认的析构函数。‎
选项：
A: 正确
B: 错误
答案: 【 正确】

123、判断题：
​类中的成员数据可以是另一个类的对象。‏
选项：
A: 正确
B: 错误
答案: 【 正确】

124、判断题：
‏一个类的构造函数中可以不包含对其内嵌对象的初始化.‏
选项：
A: 正确
B: 错误
答案: 【 错误】

125、判断题：
‎构造函数和析构函数都可以带参数。‌
选项：
A: 正确
B: 错误
答案: 【 错误】

第1章1.5.1+1.5.2测验

1、单选题：
‎（   ）的功能是对对象进行初始化。​
选项：
A: 析构函数
B: 数据成员
C: 构造函数
D: 静态数据成员
答案: 【 构造函数】

2、单选题：
‍（   ）只能访问静态成员变量。‎
选项：
A: 静态成员函数  
B: 虚函数
C: 构造函数
D: 析构函数
答案: 【 静态成员函数  】

3、单选题：
‍下列访问公有静态成员的方式，错误的是（      ）‌
选项：
A: 类名:: 静态成员名        
B: 对象名.静态成员名
C: 对象指针->静态成员名 
D: 对象指针.静态成员名
答案: 【 对象指针.静态成员名】

4、单选题：
‏下列关于静态成员的描述中，错误的是（   ）。 ‎
选项：
A: 静态成员都是使用static来说明的     
B: 静态成员是属于类的，不是属于某个对象的
C: 静态成员只可以用类名加作用域运算符来引用，不可用对象引用
D: 静态数据成员的初始化是在类体外进行的
答案: 【 静态成员只可以用类名加作用域运算符来引用，不可用对象引用】

5、单选题：
‌下列关于静态数据成员的说法，不正确的是（   ）。 ‍
选项：
A: 类中定义的公用静态数据成员，可以通过类的对象来访问
B: 类中定义的所有静态数据成员，都必须在类外初始化
C: 静态数据成员不是所有对象所共用的
D: 普通的成员函数可以直接访问类中的静态数据成员
答案: 【 静态数据成员不是所有对象所共用的 】

6、单选题：
‏下列关于友元的描述错误的是（      ）‍
选项：
A: 成员函数不可作友元
B: 类可以作友元
C: 普通函数可以作友元
D: 静态函数可以作友元
答案: 【 成员函数不可作友元 】

7、单选题：
‍下列关于友元函数的描述中，错误的是（   ）。‌
选项：
A: 友元函数不是成员函数 
B: 友元函数只可访问类的私有成员 
C: 友元函数的调用方法同一般函数 
D: 友元函数可以是另一类中的成员函数
答案: 【 友元函数只可访问类的私有成员 】

8、单选题：
‍下面对静态数据成员的描述中，正确的是（　　）‌
选项：
A: 静态数据成员可以在类体内进行初始化
B: 静态数据成员不可以被类的对象调用
C: 静态数据成员不能受private控制符的作用
D: 静态数据成员可以直接用类名调用
答案: 【 静态数据成员可以直接用类名调用】

9、单选题：
‌下面对于友元函数描述正确的是（　　） ​
选项：
A: 友元函数的实现必须在类的内部定义   
B: 友元函数是类的成员函数
C: 友元函数破坏了类的封装性和隐藏性
D: 友元函数不能访问类的私有成员
答案: 【 友元函数破坏了类的封装性和隐藏性】

10、单选题：
​下面关于静态成员函数的叙述中错误的是（   ）。‌
选项：
A: 静态成员函数可以有返回值
B: this指针可以指向静态成员函数
C: 静态成员函数可以具有指针参数
D: 静态成员函数可有具有返回值类型
答案: 【 this指针可以指向静态成员函数】

11、单选题：
‏下面关于友元的描述中，错误的是（  ）。‎
选项：
A: 友元函数可以访问该类的私有数据成员
B: 一个类的友元类中的成员函数都是这个类的友元函数
C: 友元可以提高程序的运行效率
D: 类与类之间的友元关系可以继承
答案: 【 类与类之间的友元关系可以继承】

12、单选题：
‎下面有关静态成员函数的描述中，正确的是（      ）‌
选项：
A: 在静态成员函数中可以使用this指针
B: 在建立对象前，就可以为静态数据成员赋值
C: 静态成员函数在类外定义是，要用static前缀
D: 静态成员函数只能在类外定义
答案: 【 在建立对象前，就可以为静态数据成员赋值】

13、单选题：
‌下面有关友元函数的描述中，正确的说法是（   ）‎
选项：
A: 友元函数是独立于当前类的外部函数
B: 一个友元函数不可以同时定义为两个类的友元函数
C: 友元函数必须在类的外部进行定义
D: 在类的外部定义友元函数时必须加上friend关键字
答案: 【 友元函数是独立于当前类的外部函数 】

14、单选题：
‌一个类的所有对象共享的是（  ）。 ​
选项：
A: 私有数据成员
B: 公有数据成员
C: 保护数据成员
D: 静态数据成员
答案: 【 静态数据成员】

15、单选题：
​一个类的友元函数或友元类能够通过成员操作符访问该类的（   ）‎
选项：
A: 私有成员  
B: 公有成员
C: 保护成员
D: 公有成员、保护成员和私有成员
答案: 【 公有成员、保护成员和私有成员】

16、单选题：
‎已知类A是类B的友元，类B是类C的友元，则（　　）‎
选项：
A: 类A一定是类C的友元
B: 类C一定是类A的友元
C: 类C的成员函数可以访问类B的对象的任何成员
D: 类A的成员函数可以访问类B的对象的任何成员
答案: 【 类A的成员函数可以访问类B的对象的任何成员】

17、单选题：
‏由于数据隐藏的需要，静态数据成员通常被说明为（   ）。​
选项：
A: 私有的
B: 公有的
C: 保护的
D: 不可访问的
答案: 【 私有的 】

18、单选题：
‎友元访问类的对象的成员时使用（  ）‎
选项：
A: 类的成员名
B: this指针指向成员名
C: “类名：：成员名”的形式
D: “对象名.成员名”的形式
答案: 【 “对象名.成员名”的形式】

19、单选题：
‌友元关系不能（   ） ​
选项：
A: 继承  
B: 是类与类之间的关系
C: 是一个类的成员函数与另一个类的关系
D: 提高程序的运行效率
答案: 【 继承  】

20、单选题：
‌友元的作用之一是（      ）‎
选项：
A: 提高程序的运行效率  
B: 加强类的封装
C: 实现数据的隐蔽性 
D: 增加成员函数的种类
答案: 【 提高程序的运行效率   】

21、单选题：
‌允许访问类的所有对象的私有成员,公有成员和保护成员的是(     )‏
选项：
A: 友元函数      
B: 成员函数
C: 内联函数
D: 重载函数
答案: 【 友元函数      】

22、单选题：
​静态成员函数没有（   ）‍
选项：
A: 返回值  
B: this 指针  
C: 指针参数  
D: 返回类型
答案: 【 this 指针  】

23、单选题：
​若类X是类Y的友元类，则下列访问关系中（   ）是正确的‌
选项：
A: 类X的成员不能访问类Y的私有成员
B: 类X的成员可以访问类Y的私有成员
C: 类Y的成员可以访问类X的私有成员
D: 仅类Y的公共成员可访问类X的私有成员
答案: 【 类X的成员可以访问类Y的私有成员 】

24、单选题：
‏对于友元描述正确的是（      ） ​
选项：
A: 友元是本类的成员函数
B: 友元不是本类的成员函数
C: 友元不是函数
D: 友元不能访问本类私有成员
答案: 【 友元不是本类的成员函数】

25、单选题：
‎非静态成员函数都会有一个隐含指针，它是（      ） ‏
选项：
A: self指针
B: this指针
C: current指针
D: one指针
答案: 【 this指针 】

26、单选题：
​一个类的静态数据成员所表示属性（   ）。‎
选项：
A: 是类的或对象的属性
B: 只是对象的属性
C: 只是类的属性
D: 类和友元的属性
答案: 【 只是类的属性】

27、单选题：
​类的静态成员的访问控制（   ）。‎
选项：
A: 只允许被定义为private
B: 只允许被定义为private或protected
C: 只允许被定义为public
D: 可允许被定义为private、protected或public
答案: 【 可允许被定义为private、protected或public】

28、单选题：
‌静态成员函数对类的数据成员直接访问（   ）。 ‎
选项：
A: 是不允许的
B: 只允许是静态数据成员
C: 只允许是非静态数据成员
D: 可允许是静态数据成员或非静态数据成员
答案: 【 只允许是静态数据成员】

29、单选题：
‎被非静态成员函数访问的类的数据成员（   ）。 ​
选项：
A: 可以是非静态数据成员或静态数据成员
B: 不可能是类的静态数据成员
C: 只能是类的非静态数据成员
D: 只能是类的静态数据成员
答案: 【 可以是非静态数据成员或静态数据成员 】

30、单选题：
‏静态数据成员的初始化是在（   ）中进行的。‎
选项：
A: 构造函数
B: 任何成员函数
C: 所属类
D: 全局区
答案: 【 全局区】

31、单选题：
‏当将一个类A或函数f（   ）说明为另一个类B的友元后，类A或函数f（   ）能够直接访问类B的（   ）。 ‏
选项：
A: 只能是公有成员
B: 只能是保护成员
C: 只能是除私有成员之外的任何成员
D: 具有任何权限的成员
答案: 【 具有任何权限的成员】

32、单选题：
​引入友元的主要目的是为了（   ）。‏
选项：
A: 增强数据安全性
B: 提高程序的可靠性
C: 提高程序的效率和灵活性
D: 保证类的封装性
答案: 【 提高程序的效率和灵活性】

33、单选题：
‌一个类的成员函数也可以成为另一个类的友元函数，这时的友元说明（   ）。‌
选项：
A: 需加上类域的限定
B: 不需加上类域的限定
C: 类域的限定可加可不加
D: 不需要任何限定
答案: 【 需加上类域的限定 】

34、单选题：
​一个类的友元不是该类的成员，与该类的关系密切，所以它（   ）。 ‏
选项：
A: 有this指针，有默认操作的对象
B: 没有this指针，可以有默认操作的对象
C: 有this指针，不能执行默认操作
D: 没有this指针，也就没有默认操作的对象
答案: 【 没有this指针，也就没有默认操作的对象】

35、单选题：
‎关于this指针的说法错误的是（   ） ‎
选项：
A: this指针必须显示说明
B: 当创建一个对象后，this指针就指向该对象
C: 成员函数拥有this指针
D: 静态成员函数不拥有this指针
答案: 【 this指针必须显示说明 】

36、单选题：
‍对静态成员的不正确描述是（   ）‌
选项：
A: 静态成员不属于对象，是类的共享成员
B: 静态数据成员要在类外初始化
C: 调用静态成员函数时要通过类或对象激活，所以静态成员函数拥有this指针
D: 非静态成员函数也可以操作静态数据成员
答案: 【 调用静态成员函数时要通过类或对象激活，所以静态成员函数拥有this指针】

37、单选题：
‍下列静态数据成员的特性中（      ）是错误的。​
选项：
A: 说明静态数据成员时前边要加修饰符static
B: 静态数据成员要在类体外进行初始化
C: 静态数据成员不是所有对象所共用的
D: 引用静态数据成员时，可以在其名称前加<类名>和作用域运算符
答案: 【 静态数据成员不是所有对象所共用的】

38、单选题：
​关于静态成员的描述中，（        ）是错误的。‍
选项：
A: 静态成员可分为静态数据成员和静态成员函数
B: 静态数据成员定义后必须在类体内进行初始化
C: 静态数据成员初始化不使用其构造函数
D: 静态数据成员函数中不能直接引用非静态成员
答案: 【 静态数据成员定义后必须在类体内进行初始化】

39、单选题：
‏关于类的静态成员函数描述错误的是(     ) ‍
选项：
A: 在创建对象前不存在         
B: 可以定义为类中的任何访问类型
C: 不能直接访问非静态函数
D: 不是某个对象的成员
答案: 【 在创建对象前不存在          】

40、单选题：
‍关于友元的描述中，（　　）是错误的。​
选项：
A: 友元函数是成员函数，它被说明在类体内
B: 友元函数可直接访问类中的私有成员
C: 友元函数破坏封装性
D: 友元类中的所有成员函数都是友元函数
答案: 【 友元函数是成员函数，它被说明在类体内 】

41、单选题：
​静态成员遵循类的其他成员所遵循的访问限制，除了（     ）‎
选项：
A: 静态成员函数
B: 静态数据成员初始化
C: 私有静态数据成员
D: 公有静态成员函数
答案: 【 静态数据成员初始化】

42、单选题：
‌类A是类B的友元,类B是类C的友元,则(   )是正确的.‍
选项：
A: 类B是类A的友元                 
B: 类C是类A的友元
C: 类A是类C的友元
D: 以上都不对
答案: 【 以上都不对】

43、单选题：
‏如果类 B 被说明成类 A 的友元，则（　　）。 ‏
选项：
A: 类 A 的成员即类 B 的成员             
B:  类 B 的成员函数可以访问类 A 的成员
C:  类 B 的成员即类 A 的成员
D: 类 A 也是类 B 的友元
答案: 【  类 B 的成员函数可以访问类 A 的成员】

44、单选题：
‎如果类A被声明成类B的友元，则(     ) ‎
选项：
A: 类A的成员即类B的成员
B: 类B的成员即类A的成员
C: 类A的成员函数不得访问类B的成员
D: 类B不一定是类A的友元
答案: 【 类B不一定是类A的友元】

45、单选题：
‎如果在类外有函数调用CPoint::func()；则函数func()是类CPoint的（   ）。‍
选项：
A: 私有静态成员函数
B: 公有非静态成员函数
C: 公有静态成员函数
D: 友元函数
答案: 【 公有静态成员函数】

46、单选题：
‏设类Test中存在成员static int x，则下列哪种初始化方式是正确的（      ） ‎
选项：
A: Test::int x=25；
B: int x=25；
C: int Test::x=25；
D: int Test x=25；
答案: 【 int Test::x=25； 】

47、单选题：
​声明友元使用下列哪个关键字（      ）‍
选项：
A: class
B: const
C: friend 
D: virtual
答案: 【 friend 】

48、单选题：
‌下面对友元的错误描述是（） ‍
选项：
A: 关键字friend用于声明友元
B: 一个类的成员函数可以是另一个类的友元
C: 友元函数访问对象的成员不受访问特性影响
D: 友元函数通过this指针访问对象成员
答案: 【 友元函数通过this指针访问对象成员】

49、单选题：
‌下列关于静态数据成员的描述中，正确的是（       ）。‌
选项：
A: 静态数据成员是类的所有对象所共有的
B: 静态数据成员要在构造函数内初始化
C: 类的每个对象有自己的静态数据成员
D: 静态数据成员不能通过类的对象调用
答案: 【 静态数据成员是类的所有对象所共有的 】

50、单选题：
‎以下关于this指针的叙述中正确的是：（   ） ‌
选项：
A: 任何与类相关的函数都有this指针
B: 类的成员函数都有this指针
C: 类的友元函数都有this指针
D: 类的非静态成员函数才有this指针
答案: 【 类的非静态成员函数才有this指针】

51、单选题：
​有如下程序：‍# include <iostream>
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