面向对象程序设计复习题1.docx

面向对象程序设计复习题1.docx

《面向对象程序设计复习题1.docx》由会员分享，可在线阅读，更多相关《面向对象程序设计复习题1.docx（20页珍藏版）》请在冰豆网上搜索。

面向对象程序设计复习题1

一．选择题

1．对类的构造函数和析构函数描述正确的是（）。

A. 构造函数可以重载，析构函数不能重载

B. 构造函数不能重载，析构函数可以重载

C. 构造函数可以重载，析构函数也可以重载

D. 构造函数不能重载，析构函数也不能重载

2．继承具有（），即当基类本身也是某一个类派生类时，底层的派生类也会自动继承间接基类的成员。

A）规律性B.传递性C.重复性D.多样性

3．假设OneClass为一个类，则该类的拷贝初始化构造函数的声明语句为（）。

A.OneClass（OneClassp）;B.OneClass&（OneClassp）;

C.OneClass（OneClass&p）;D.OneClass（OneClass*p）;

4．对于结构中定义的成员，其默认的访问权限为（）。

A.publicB.protectedC.privateD.static

5．下面对静态数据成员的描述中，不正确的是（）。

A.静态数据成员可以在类体内进行初始化

B.静态数据成员不可以在类体内进行初始化

C.静态数据成员能受private控制符的作用

D.静态数据成员调用前必须初始

6.C++中的类有两种用法：

一种是类的实例化，即生成类对象，并参与系统的运行；另一种是通过（　　　）派生了新的类。

A.复用B.继承C.封装D.引用

7.假定AA为一个类，a为该类公有的数据成员，x为该类的一个对象，则访问x对象中数据成员a的格式为（）。

A.x（a）B.x[a]C.x->aD.x.a

9.对于一个类的构造函数，其函数名与类名（）。

A.完全相同B.基本相同C.不相同D.无关系

10.一个类的构造函数通常被定义为该类的（）成员。

A.公有B.保护C.私有D.友元

11.一个类的析构函数通常被定义为该类的（）成员。

A.私有B.保护C.公有D.友元

12.一个类的静态数据成员所表示属性（）。

A.是类的或对象的属性B.只是对象的属性

C.只是类的属性D.类和友元的属性

13.类的析构函数的作用是（）。

D

A．一般成员函数B．类的初始化C．对象初始化D．删除对象的善后工作

16.下列对基类和派生类关系的描述中，错误的是（）。

A．派生类是基类的具体化B．派生类是基类的子集

C．派生类是基类定义的延续D．派生类是基类的组合

17.下列对派生类的描述中，错误的是（）。

D

A．一个派生类可以作为另一个派生类的基类B．派生类至少有一个基类

C．派生类的缺省继承方式是privateD．派生类只继承了基类的公有成员和保护成员

18.下列对继承的描述中，错误的是（）。

D

A．析构函数不能被继承

B．派生类也是基类的组合

C．派生类的成员除了它自己的成员外，还包含了它的基类的成员

D．派生类中继承的基类成员的访问权限到派生类保持不变

19.派生类的对象对它的基类成员中（）是可以访问的。

A

A．公有继承的公有成员B．公有继承的私有成员

C．公有继承的保护成员D．私有继承的公有成员

20.下列说法错误的是（）。

B

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

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

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

D．保护继承的基类中的public成员在派生类中仍是protected的

21.下面叙述错误的是（）。

A

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

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

C．基类的protected成员在private派生类中是private的

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

22．下列对派生类的描述中，错误的是（）。

A.一个派生类可以作为另一个派生类的基类

B.派生类至少有一个基类

C.派生类的缺省继承方式是private

D.派生类只含有基类的公有成员和保护成员

25．设置虚基类的声明中，正确的是（）。

A.简化程序B.消除二义性C.提高运行效率D.减少目标代码

26．关于虚函数的描述中，正确的是（）。

A．虚函数是一个静态成员函数

B．虚函数是一个非成员函数

C．虚函数即可以在函数说明定义，也可以在函数实现时定义

D．派生类的虚函数与基类中对应的虚函数具有相同的参数个数和类型

27．下列描述中，（）是抽象类的特征。

A．可以说明虚函数B．可以进行构造函数重载

C．可以定义友元函数D．不能说明其对象

28.静态数据成员的初始化是在（）中进行的。

A.构造函数B.任何成员函数

C.所属类D.全局区

?

29.当将一个类A或函数f（）说明为另一个类B的友元后，类A或函数f（）能够直接访问类B的（）。

A.只能是公有成员B.只能是保护成员

C.只能是除私有成员之外的任何成员D.具有任何权限的成员

30.在重载一个运算符时，其参数表中没有任何参数，这表明该运算符是（）。

A.作为友元函数重载的1元运算符B.作为成员函数重载的1元运算符

C.作为友元函数重载的2元运算符D.作为成员函数重载的2元运算符

31.关于运算符重载，下列说法正确的是（）。

A.重载时，运算符的优先级可以改变。

B.重载时，运算符的结合性可以改变。

C.重载时，运算符的功能可以改变。

D.重载时，运算符的操作数个数可以改变。

32.从一个基类派生出的各个类的对象之间（）。

A.共享所有数据成员，每个对象还包含基类的所有属性

B.共享部分数据成员，每个对象还包含基类的所有属性

C.不共享任何数据成员，但每个对象还包含基类的所有属性

D.共享部分数据成员和函数成员

33.C++的继承性允许派生类继承基类的（）。

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

B.部分特性，但不允许增加新的特性或重定义基类的特性

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

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

34.派生类的成员函数可以直接访问基类的（）成员。

A.所有B.公有和保护C.保护和私有D.私有

35.当派生类中有和基类一样名字的成员时，一般来说，（）。

A.将产生二义性B.派生类的同名成员将覆盖基类的成员

C.是不能允许的D.基类的同名成员将覆盖派生类的成员

36．关于纯虚函数和抽象类的描述中，错误的是（）。

A．纯虚函数是一种特殊的虚函数，它没有具体的实现

B．抽象类是指具体纯虚函数的类

C．一个基类中说明有纯虚函数，该基类派生类一定不再是抽象类

D．抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出

37．如果一个类至少有一个纯虚函数，那么就称该类为（）。

A．抽象类B．虚函数C．派生类D．以上都不对

38．要实现动态联编，必须通过（）调用虚函数。

A．对象指针B．成员名限定C．对象名D．派生类名

39.以下（）成员函数表示虚函数。

A．virtualintvf（int）;B．voidvf（int）=0;

C．virtualvoidvf（）=0;D．virtualvoidvf（int）{};

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

A．virtual可以用来声明虚函数

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

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

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

41.在成员函数中进行双目运算符重载时，其参数表中应带有

（1）个参数。

A.0B.1C.2D.3

42.在重载一运算符时，若运算符函数的形参表中没有参数，则不可能的情况是（）。

A.该运算符是一个单目运算符。

B.该运算符函数有一个隐含的参数this。

C.该运算符函数是类的成员函数。

D.该运算符函数是类的友元函数。

43.下面对于友元函数描述正确的是（）。

A．友元函数的实现必须在类的内部定义

B．友元函数是类的成员

C．友元函数破坏了类的封装性和隐藏性

D．友元函数不能访问类的私有成员

44.为了使类中的某个成员不能被类的对象通过成员操作符访问，则不能把该当成员的访问权限定义为（）。

A．publicB．protectedC．privateD．ststic

45.下面对静态数据成员的描述中，正确的是（）。

A．静态数据成员可以在类体内进行初始化

B．静态数据成员不可以在类体内进行初始化

C．静态数据成员不能受private控制符的作用

D．静态数据成员可以直接用类名调用

46.下面对静态数据成员的描述中，正确的是（）。

A．静态数据成员是类的所有对象共享的数据

B．类的每一个对象都有自己的静态数据成员

C．类的不同对象有不同的静态数据成员值

D．静态数据成员不能通过类的对象调用

49.C++类体系中，不能被派生类继承的有（）。

A．构造函数B．虚函数C．静态成员函数D．赋值操作函数

47下列虚基类的声明中，正确的是（）。

A．classvirtualB:

publicAB．virtualclassB:

publicA

C．classB:

publicAvirtualD．classB:

virtualpublicA

48在下面的表达式中，不表示虚继承的是（）。

A．virtualpublicB．publicvirtual

C．publicD．virtual

49下列关于动态联编的描述中，错误的是（）。

A．动态联编是以虚函数为基础

B．动态联编是运行时确定所调用的函数代码的

C．动态联编调用函数操作是指向对象的指针或对象引用

D．动态联编是在编译时确定操作函数的

50.编译时的多态性可以通过使用（）获得。

　A．虚函数和指针B．重载函数和析构函数

C．虚函数和对象D．虚函数和引用

51.关于纯虚函数和抽象类的描述中，错误的是（）。

A．纯虚函数是一种特殊的虚函数，它没有具体的实现

B．抽象类是指具体纯虚函数的类

C．一个基类中说明有纯虚函数，该基类派生类一定不再是抽象类

D．抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出

二.填空题

1.重载插入运算符<<时，其运算符函数的返回值类型应当是_ostream&___。

2.派生类可以定义其__基类______中不具备的数据和操作。

3.对象将其大部分实现细节隐藏起来，这种机制称为_　　封闭　　_。

4.建立类和类的对象时，系统对　类不分配内存，系统对　对象　分配内存。

类、对象

5.基类和派生类的关系称为__　　继承____。

6.当保护继承时，基类的　　　成员在派生类中成为保护成员，派生类对象不能直接访问基类的　　　成员。

公有或保护、任何

7.C＋＋支持两种多态性：

编译时的多态性（重载）和运行时的多态性（虚函数）。

编译、运行

8.在C++中定义类时，通常是利用描述对象的“特征”;利用描述对象的“行为”。

变量、函数

9.假定用户为类AB定义了一个构造函数"AB（intaa，char*bb＝NULL）：

a（aa），b（bb）{}”，

则该类中至少包含有个数据成员。

2

10.类是对象的　　　　　；而对象则是类的具体　　　　。

抽象、实例

11.如果不做特殊说明，类成员的默认访问权限是private　　；结构成员的默认访问权限是public　　。

私有、公有

12.在定义对象的同时初始化其成员变量，需要利用　　　　函数，用于初始化变量的值可以是固定的常量，也可以通过　　　　　获得。

构造、参数

14.在私有继承关系下，基类的公有成员和保护成员将成为派生类中的　私有　成员，它们只能由派生类的成员函数来访问；基类的私有成员将成为派生类中的　　　　成员。

私有、成员函数、不可访问的

13.在保护继承中，基类中的　　　　　　　、　　　　　　　是可见的。

公有成员、保护成员

14.面向对象方法构造的系统，其基本单位是__　对象　　　　__。

15.在C++中，编译时的多态性是通过__　　_实现的，而运行时的多态性则是通过　　_　　__实现的。

重载、虚函数

16.生成一个派生类对象时，先调用　的构造函数，然后调用　　　的构造函数。

基类、派生类

17.AAoperator+（AAx）表示为  　  。

运算符＋重载

18.若在类的定义体中只给出了一个成员函数的原型，则在类外给出完整定义时，其函数名前必须加上和两个冒号分隔符。

类名

19.若采用x.abc（y）表达式调用一个成员函数，在成员函数中使用的就代表了类外的x对象。

*this

20.假定用户没有给一个名为AB的类定义析构函数，则系统为其定义的析构函数为。

~AB（）{}

21.类的成员按访问权限可分为三类：

公有、　　　、　　　。

私有、保护

22．在一个类中定义拷贝构造函数的目的，是为了当利用该类的一个对象初始化另一个对象时，能够避免这两个对象的同一指针同时指向同一块地址。

23.假定AB为一个类，则执行“ABa[10];”语句时，系统自动调用该类构造函数的次数为________。

10

24.假定要把aa定义为AB类中的一个常量整数型数据成员，则定义语句为____________。

constintaa

25．假定AB为一个类，该类中构造函数含有一个语句new申请存储空间，则在该类的析构函数中应该包含有一条______________语句。

delete

26.静态成员函数访问类的静态数据成员，可以访问类的非静态数据成员和静态成员。

只能，非静态函数

34.一个类的成员函数也可以成为另一个类的友元函数，这时的友元说明必须在函数名前加上的限定。

friend

27.一个单目运算符作为类的成员函数重载时有________个参数；如果作为独立函数重载，则有________个参数。

0,1

28.若多个基类及其派生类中都定义了同名函数成员，要访问相应函数时，就需要在函数名前加上______和类区分符。

基类名

29.引进虚基类的根本目的是为了消除___。

二义性

三．写出下列程序的运行结果

（1）#include

#include

usingnamespacestd;

classA{

char*a;

public:

A（char*s）{

a=newchar[strlen（s）+1];

strcpy（a,s）;

cout<

~A（）{delete[]a;

cout<<"Destructor!

"<

};

voidmain（）

{Ax（"LiMing"）;　

A　y（"Zhang"）;　}

（2）#include

usingnamespacestd;

intn=0;

classA{

inta;

public:

A（intaa=0）{a=aa;n++;}

~A（）{n--;cout<

voidshow（）{cout<

};

voidmain（）

{Aa;a.show（）;

{Ax[2];

x[1].show（）;

}

a.show（）;

}

（3）#include

usingnamespacestd;

classA

{inta,b;　　　　　　　　　　　　　　　　　　　　

public:

A（）

{a=b=0;cout<

A（intaa,intbb）

{a=aa;b=bb;cout<

};

voidmain（）

{Ax,y（10,5）;}

（4）#include

usingnamespacestd;

classBB

{inta,b;

public:

BB（inti=0,intj=1）{a=i;b=j;}

BBoperator+（BBc）

{BBd;

d.a=a+c.a*10;d.b=b+c.b*10;

returnd;}

BBoperator-（BBc）

{BBd;

d.a=a*c.a;d.b=b*c.b;

returnd;}

voidshow（）

{cout<<'（'<

};

voidmain（）

{BBx（2,6）,y（5,5）,z;

z=x+y;z.show（）;

z=x-y;z.show（）;

}

（5）#include

usingnamespacestd;

classEX

{intx,y;

public:

EX（inti=0,intj=1）{x=i;y=j;}

EXoperator*（EXz）

{EXd;

d.x=x*z.x;d.y=y*z.y;

returnd;}

EXoperator/（EXc）

{EXd;

d.x=x-c.x;d.y=y-c.y;

returnd;}

voidshow（）

{cout<<'（'<

};

voidmain（）

{EXa（30,10）,b（2,5）,c;

c=a*b;

c.show（）;

c=a/b;

c.show（）;

}

（6）#include

usingnamespacestd;

classPoint{

intx,y;

public:

Point（）{x=1;y=1;}

~Point（）{cout<<"Point"<

};

voidmain（）

{

Pointa;

}

（9）

#include

usingnamespacestd;

intcount=0;

classPoint

{intx,y;

public:

Point（）{x=1;y=1;count++;}

~Point（）{count--;}

}；

voiddisplay（）

{

cout<<"Thereare"<

}

voidmain（）

{Pointa;

display（）;

{Pointb[5];display（）;}

display（）;

}

（10）#include

usingnamespacestd;

classEX1

{inta,b;　　　　　　　　　　　　　　　　　　　　

public:

EX1（）

{a=b=1;cout<

EX1（intaa,intbb=100）

{a=aa;b=bb;cout<

};

voidmain（）

{

EX1x,y（10,2）;

EX1z（200）;

}

（11）#include

usingnamespacestd;

classCsample

{inti;

public:

Csample（）

{cout<<"constructor1"<

Csample（intval）

{cout<<"Constructor2"<

voidDisplay（）

{cout<<"i="<

~Csample（）

{cout<<"Destructor"<

};

voidmain（）

{

Csamplea,b（10）;

a.Display（）;

b.Display（）;

}

（12）#include

usingnamespacestd;

classCsample

{private:

inti;

staticintk;

public:

Csample（）;

voidDisplay（）;

};

intCsample:

:

k=0;

Csample:

:

Csample（）

{

i=0;

k++;

}

voidCsample:

:

Display（）

{

cout<<"i="<

}

voidmain（）

{

Csamplea,b;

a.Display（）;

b.Display（）;

}

（13）#include

#include

usingnamespacestd;

structA

{

charc[20];floatf;};

voidf（A&t）

{

strcpy（t.c,”MALIANG”）;

t.f=70.5;}

voidmain（）

{Az={“LIMING”,77.5};

f（z）;

cout<

}

（14）#include

usingnamespacestd;

classCsample

{

inti;

public:

Csample（）;

voidDisplay（）;

~Csample（）;

};

Csample:

:

Csample（）

{cout<<"Constructor"<<",";i=0;}

voidCsample:

:

Display（）

{cout<<"i="<

Csample