面向对象编程技术复习题

模拟题（一）

一、单项选择题（1×25=25分）

1． 关于C++与C 语言的关系的描述中，错误的是（ ）

A ． C 语言是C++的一个子集 B ． C++对C 语言是兼容的

C ． C++对C 语言进行了一些改进 D ． C++和C 语言都是面向对象的

2．设int m=0；，下列表示引用的方法中，（ ）是正确的。

A int &x=m； B int &y=10； C int &z； D float &t=&m

3．设void f1(int &x，char * p)；int m；char s[ ]="c++"；以下调用合法的是（ ）。

A f1(&m，&s) B f1(&m，s) C f1(m，s) D f1(m，&s)

4. 数组定义为"int a[4][5];", 引用"a[1]+3"表示（ ）。

A 、a 数组第1行第3列元素的地址 B 、a 数组第1行第3列元素的值 C 、a 数组第4行的首地址 D 、a 数组第4列的首地址

5、 假定MyClass 为一个类, 则执行MyClass a, b(2),*p;语句时，自动调用该类构造函数_________次。

A)2 B)3 C)4 D)5

6． 对类的构造函数和析构函数描述正确的是_________。

A)构造函数可以重载, 析构函数不能重载 B) 构造函数不能重载, 析构函数可以重载

C)构造函数可以重载, 析构函数也可以重载 D) 构造函数不能重载, 析构函数也不能重载

7． 在C++中, 数据封装要解决的问题是_________。

A)数据的规范化 B) 便于数据转换 C) 避免数据丢失

D) 防止不同模块之间数据的非法访问

8． 对于结构中定义的成员, 其默认的访问权限为_________。

A)public B)protected C)private D)static

9． 假定MyClass 为一个类, 则该类的拷贝初始化构造函数的声明语句为_________。

A)MyClass &(MyClass x); B)MyClass (MyClass x) C)MyClass (MyClass &x); D)MyClass (MyClass *x)

10．为了使类中的某个成员不能被类的对象通过成员操作符访问, 则不能把该成员的访问权限定义为_________。

A)public B)protected C)private D)static

11． 对于下面定义的类MyClass ，在函数f()中将对象成员n 的值修改为50的语句应该是_________。

Class MyClass

{

public:

MyClass(int x){n = x;}

void SetNum(int nl){n = nl;}

private:

int n;

}

int f()

{

MyC1ass *ptr = new MyClass(45);

__________________

}

A)MyClass(50) B)SetNum(50) C)ptr->SetNum(50)

D)ptr->n=50

12． 类的析构函数的作用是_________。

A)一般成员函数 B) 类的初始化 C) 对象的初始化

D) 对象被删除时的清理工作

13． 有如下定义语句: int a[]={1,2,3,4,5};,则对语句int *p=a;正确的描述是_________。

A)语句 int *p=a; 定义不正确

B)语句 int *p=a; 初始化变量p, 使其指向数组对象a 的第一个元素

C)语句 int *p=a; 是把a[0]的值赋给变量p

D)语句 int *p=a; 是把a[1]的值赋给变量p

14．关于new 运算符的错误的描述是_________。

A)使用运算符new 创建对象数组时必须定义初始值 B) 使用运算符new 创建对象时, 会调用类的构造函数

C)运算符new 可以用来动态创建对象和对象数组 D) 使用new 运算符创建的对象可以使用运算符delete 删除

15. 一个函数功能不太复杂，但要求被频繁调用，选用_________

A. 内联函数 B. 重载函数 C. 递归函数 D. 嵌套函数

16．下列运算符中,_________运算符在C++中不能重载。

A)= B)( ) C):: D)++

17． 在一个类中可以对一个操作符进行_________重载。

A)1种 B)2种以下 C)3种以下 D) 多种

18．假定AB 为一个类，则执行AB x；语句时将自动调用该类的_________。

A. 有参构造函数 B. 无参构造函数 C. 拷贝构造函数 D. 赋值构造函数

19． 下列关于C++运算符函数的返回类型的描述中, 错误的是_________。

A.可以是类类型 B. 可以是int 类型 C. 可以是void 类型 D. 可以是float 类型

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

A.规律性 B. 传递性

C.重复性 D. 多样性

21．下列说法中错误的是_________。

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

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

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

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

22．派生类的构造函数的成员初始化列表中，不能包含_________。

A.基类的构造函数 B. 派生类中子对象的初始化

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

23． C++类体系中，不能被派生类继承的有_________。

A.构造函数 B. 虚函数

C.静态成员函数 D. 赋值操作函数

24． _________是一个在基类中说明的虚函数, 它在该基类中没有定义, 但要求任何派生类都必须定义自己的版本。

A.虚析构函数 B. 虚构造函数

C.纯虚函数 D. 静态成员函数

25．下列描述中,_________是抽象类的特性。

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

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

二、填空题（10空，1×10=10分）

1. 使用const 语句定义一个标识符常量时，则必须对它同时进行__________。

2. 重载函数的_______是相同的，但_______是不同的。

3. 类是对具有共同属性和行为的一类事物的抽象描述，共同属性被描述为类中的______，

共同行为被描述为类中的______。

4. 非成员函数应声明为类的_________才能访问这个类的private 成员。

5. C++提供的_________机制允许一个派生类继承多个基类，即使这些基类是相互无关

的。

6. 派生类对基类的继承有三种方式: __________、__________ 和__________。

三．判断题（1×10=10 10分）

1．构造函数有且只有一个 （ ）

2．一个类可以定义多个对象 （ ）

3．基类和派生类中出现同名函数，也存在二义性问题 （ ）

4. 一个C++语言程序总是从第一个函数开始执行. ( )

5．对对象成员的构造函数的调用顺序取决于这些对象成员在类中说明的顺序, 与它们在成员初始化列表中给出的顺序无关. （ ）

6. 一个类可以定义多个对象 （ ）

7. 运算符重载可以改变操作数的个数 （ ）

8. 一个派生类可以作为另一个派生类的基类 （ ）

9. 派生类的对象对它的基类成员中公有继承的私有成员是可以访问 （ ）

10. 纯虚函数是一种特殊的虚函数，它没有具体的定义 （ ）

四、读程题（每小题5分，共15分）

1.. 写出下面程序运行的结果

#include

class B0

{ public:

virtual void display ( ) {cout

};

class B1:public B0

{ public:

void display ( ) {cout

};

class D1:public B1

{ public

void display ( ) {cout

};

void fun (B0 *ptr)

{ ptr->display ( );}

void main( )

{ B0.b0;

B1.b1;

D1.d1;

B0 *p;

P=&b0;

fun(p)

p=&b1;

fun(p);

p=&d1;

fun(p);

}

2. ..写出下面程序运行的结果

class test{

private:

int num;

public:

test( );

int geint( ){return num;}

~test( );

};

test :: test( )

{ num=0;}

test:: ~test( )

{

cout

}

void main( )

{

test x[3];

cout

}

3、指出下面程序中的错误，并写出纠正的语句。

void main( )

{

cin>>x;

int p=x*x;

cout

}

五、简答题（每小题5分，共15分）

１. 构造函数和析构函数有何作用？

2 .什么叫做拷贝构造函数？拷贝构造函数何时被调用？

3. 什么是多态？运行时的多态是通过什么函数来实现的？

六、编程题（共25分）

1． 实现一个类A ，在A 中有两个私有的整型变量a 和b ，定义构造函数对a 和b 进行初始

化，并实现成员函数geta （）取得a 的值和getb （）取b 的值。实现类B 从A 继承，覆盖geta （），使其返回a 的2倍。（12分）

2. 设计一个描述屏幕上两点之间距离的类Distance, 其数据成员包括Point 类的2个对象p1

和p2(类组合) ，Distance 类的主要功能是计算2点间的距离，在构造函数中实现。要求包括：构造函数和析构函数、拷贝构造函数、内联成员函数；写出主程序，使用Distance 类。（13分）

参考答案和评分标准

﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉

一、选择题（每题1分，共25分）

评分标准：

总分25分。每答对1题，得1分；答错或不答均不得分。

1.D 2.A 3.C 4.A 5.B

6.A 7.D 8.A 9.C 10.A

11.C 12.D 13.B 14.A 15.A

16.C 17.D 18.B 19.C 20.B

21.B 22.C 23.A 24.C 25.D

二、填空题（每空1分，共10分）

评分标准：

总分10分。每答对1空，得1分；答错或不答均不得分。

1. 初始化

2. 函数名 参数类型或个数

3. 数据成员 函数成员

4. 友元函数

5. 多继承

6. public private protected 或者 公有 私有 保护

三、判断题（每题1分，共10分）

1. 错 2. 对 3. 错 4. 错 5. 对 6. 对 7. 错 8. 对 9. 错 10. 对

四、读程题（每题 5分 共15分）

评分标准：

答案不完全，酌情扣分；答错或不答均不得分。

1．

B0::display( )

B1::display( )

D1::display( )

2．

Exiting main

Destructor is active

Destructor is active

Destructor is active

3. 答：错误有3:

(1)首先程序中用到输出对象cout ，则必须在程序首部加上文件包含语句#include

(2)变量必须先定义后使用，而x 未定义就输入值是错误的,int x;。

(3)如果程序要输出p 的值，括号位置是不对的，应写为：cout

五、简答题（每题5分，共15分 ）

评分标准：

每答对1小题得5分；答案不完全，酌情扣分；答错或不答均不得分

(1) 答：构造函数的作用就是在对象被创建时利用特定的值构造对象，将对象初始化为

一个特定的状态；

(2) 析构函数的作用是完成对象被删除前的一些清理工作。

2. 拷贝构造函数是一种特殊的构造函数，具有一般构造函数的所有特性，其形参是本

类对象的引用。

以下三种情况均可出现拷贝构造函数被调用：1）当用一个类的对象去初始化该类的

另一个对象时 2）如果函数的参数是类的对象，调用函数时，进行形参和实参结合时；

3）如果函数的返回值是类的对象，函数执行完成返回调用者时。

3. 多态性指是同样的消息被不同类型的对象接收产生不同的行为；运行时的多态通过

定义虚函数来实现。

六 编程题（共25分 ）

2．评分要点：构造函数、继承、实例化

class A

{

int a;

int b;

public:

A(int m,int n):a(m),b(n) {}

int geta() {return a; }

int getb() {return b; }

};

class B :public A

{

public:

B(int m,int n):A(m,n) {}

int geta() {return A::geta()*2; }

};

void main()

{

B b(2,2);

b.geta();

}

3．评分要点：类聚集涉及的拷贝构造函数、初始化，实例化

#include

#include

class Point //Point类定义

{

public:

Point(int xx=0, int yy=0) {X=xx;Y=yy;}

Point(Point &p);

int GetX() {return X;}

int GetY() {return Y;}

private:

int X,Y;

};

Point::Point(Point &p) //拷贝构造函数的实现

{

X=p.X;

Y=p.Y;

cout

}

//类的聚集

class Distance //Distance类的定义

{

public: //外部接口

Distance(Point xp1, Point xp2);

double GetDis(){return dist;}

private: //私有数据成员

Point p1,p2; //Point类的对象p1,p2

double dist;

};

//类的聚集的构造函数

Distance::Distance(Point xp1, Point xp2):p1(xp1),p2(xp2)

{

cout

double x=double(p1.GetX()-p2.GetX());

double y=double(p1.GetY()-p2.GetY());

dist=sqrt(x*x+y*y);

}

//主函数

void main()

{

Point myp1(1,1),myp2(4,5); //定义Point 类的对象

Distance myd(myp1,myp2); //定义Distance 类的对象

cout

cout

}

模拟题（二）

一、单项选择题（0.5×20=10分）

1.C++对C 语言作了很多改进，即从面向过程变成为面向对象的主要原因是( )

A. 增加了一些新的运算符

B. 允许函数重载，并允许设置缺省参数

C. 规定函数说明符必须用原型

D. 引进了类和对象的概念

2. 在int a=3,int *p=&a；中，*p的值是( )

A. 变量a 的地址值 B. 无意义

C. 变量p 的地址值 D. 变量a 的值

3. 一个函数功能不太复杂，但要求被频繁调用，选用( )

A. 内联函数 B. 重载函数

C. 递归函数 D. 嵌套函数

4. 构造函数不具备的特征的是( )

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

B. 构造函数可以重载

C. 构造函数可以设置默认参数

D. 构造函数必须指定类型说明

5. 通常，拷贝构造函数的参数是( )

A. 某个对象名 B. 某个对象的成员名

C. 某个对象的引用名 D. 某个对象的指针名

6. 如果类A 被说明成类B 的友元，则( )

A. 类A 的成员即类B 的成员

B. 类B 的成员即类A 的成员

C. 类A 的成员函数不得访问类B 的成员

D. 类B 不一定是类A 的友元

7.C++类体系中，不能被派生类继承的有( )

A. 转换函数 B. 构造函数

C. 虚函数 D. 静态成员函数

8. 要禁止修改指针p 本身，又要禁止修改p 所指向的数据，这样的指针应定义为( )

A.int j=9; const int *p=&j; B.int j=9; int const *p=&j;

C.int j=9;int *const p=&j; D.int j=9; const int * const p=&j;

9. 静态成员函数没有( )

A. 返回值 B.this 指针

C. 指针参数 D. 返回类型

10．设int m=0；，下列表示引用的方法中，（ ）是正确的。

A int &x=m； B int &y=10； C int &z； D float &t=&m

11．设void f1(int &x，char * p)；int m；char s[ ]="c++"；以下调用合法的是（

A f1(&m，&s) B f1(&m，s) C f1(m，s) D f1(m，&s)

。。 ）

12．静态成员函数能访问（ ）。

A.静态的数据成员

B.非静态的成员函数

C.非静态的数据成员

D.以上都不对

13. 一个类的友元函数能够访问该类的（ ）

A ． 私有成员 B. 保护成员 C. 公有成员 D. 所有成员

14. 下列运算符中（ ）运算符在C++中不能重载

A. ?: B.+ C.- D.

15 设置虚基类的目的是（ ）

A. 简化程序

B. 消除二义性

C. 提高运行效率

D. 减少目标代码

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

A)构造函数可以重载, 析构函数不能重载

B)构造函数不能重载, 析构函数可以重载

C)构造函数可以重载, 析构函数也可以重载

D)构造函数不能重载, 析构函数也不能重载

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

A)public

B)protected

C)private

D)static

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

A)public

B)protected

C)private

D)static

19． 对于常成员函数, 下面描述正确的是（ ）。

A)类的成员函数可以操作常对象

B)类的成员函数不能操作常对象

C)只有常成员函数可以操作常对象

D)在常成员函数中, 常对象可以被更新

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

A.虚基类子对象的初始化由最派生类完成

B.虚基类成员的初始化次数与虚基类下面的派生类个数无关

C.设置虚基类的目的是消除二义性

D.带有虚基类的多层派生类构造函数的成员初始化列表中可能要列出对虚基类构造函数的调用

二、填空题（20空，1×20=20分）

7. 在C++中，函数的参数有两种传递方式，它们是值传递和____________。

8. 指针定义 char * const p 表示__________是常量；指针定义 const char * p 表示

__________是常量。

9. 指向类成员的指针包含指向类___________的指针和指向类__________的指针。

10. 非类成员函数应声明为类的_________才能访问这个类的private 成员。

11. 假定要访问一个指针p 所指对象中的b 指针成员所指的对象，则表示方法为

_________ 。

12. 将关键字const 写在函数头之后，函数体之前，说明该函数是一个const 成员函数。此时

const 不是指定函数的返回值，而是修饰___________指针。

13. 静态数据成员在类外进行初始化，且静态数据成员的一个拷贝被类的所有对象

____________。

14. C++提供的_________机制允许一个派生类继承多个基类，即使这些基类是相互无关

的。

15. 一个抽象类的派生类可以实例化的必要条件是实现了所有的__________。

16. 列举多态在C++中的三种表现方式: __________、__________ 和__________。

17. 为了在对象生存期结束时释放其指针成员所指向的动态存储空间，通常需要为该类定义

______。

18. 通过C++语言中类的__________，可以扩充和完善已有类以适应新的需求。

19. 友元有两种表现形式______________、_____________。

20. 可以通过____________或者_____________两种方式来解决二义性问题。

三．判断题（1×10=10 10分）

1. 编译const int i=100; int * const p2=&i; 将会出现错误 （ ）

2. 在类中，如果不做特别说明，所指成员均为公有类型 （ ）

3. 基类和派生类中出现同名函数，将存在二义性问题 （ ）

4. 对虚函数的调用必须是静态联编 （ ）

5. 对对象成员的构造函数的调用顺序取决于这些对象成员在类中说明的顺序, 与它们在成员

初始化列表中给出的顺序无关. （ ）

6. 构造函数的访问属性必需是public （ ）

7. 运算符重载可以改变操作数的个数 （ ）

8. 一个派生类可以作为另一个派生类的基类 （ ）

9. 公有继承的派生类对象对它的基类成员中的私有成员是可以访问 （ ）

10. 纯虚函数是一种特殊的虚函数，它没有具体的定义函数体 （ ）

四、读程填空、写出运行结果（每小题5分，共10分）

1... 在下面横线处填上适当字句; 完成类中成员函数的定义.

class A {

int*a;

public:

A(int aa=0) {

a=________;

}

~A(){________;}

}; 答案为:new int(aa) delete a

2.. 写出下面程序运行的结果

#include

class B1

{public:

B1(int i) {cout

};

class B2

{ public:

B2(int j) {cout

};

class B3

{ public

B3( ) {cout

};

class C :public B2 ,public B1 ,public B3

{ public:

C(int a, int b ,int c ,int d): B1(a) ,member B2(d),member B1(c) ,B2(b) { }

private:

B1 member B1;

B2 member B2;

B3 member B3;

}；

void main( )

{ c .obj(1 ,2 ,3 ,4);

}

五、简答题（每小题5分，共15分）

１. 何为赋值兼容规则? 它可以运用在那些情形中？

２.. 类的缺省构造函数有那几中定义形式，能不能同时定义两个以上的缺省构造函数?

3. 若程序员没有定义拷贝构造函数，则编译器自动生成一个缺省的拷贝构造函数，它可能

会产生什么问题？

六、编程题（共35分）

1. 利用静态数据成员的概念，编写一个类，可以统计目前存在多少个该类的对象 (10

分 ) 。

2. 定义一个复数(complex)类，包含复数的实部和虚部，重载运算符号 ＋ 和 * ，实现

两个复数的相加和相乘，并在主程序中测试复数的乘法（13分）。

3. 编写程序定义一个车(vehicle)基类，有Run 、Stop 等成员函数，由此派生出自行车(bicycle)

类、汽车类（motorcar ），从bicycle 类和motorcar 类派生出摩托车类（motorcycle ），它们都有Run 、Stop 等成员函数。在main()函数中定义vehicle 、bicycle 、motorcar 、motorcycle 的对象，用vehicle 类型的指针来调用几个对象的Run()、Stop()函数成员函数（12分）。

参考答案和评分标准

﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉﹉

一、选择题（每题1分，共20分）

评分标准：

总分35分。每答对1题，得1分；答错或不答均不得分。

1.D 2.D 3.A 4.D 5.C

6.D 7.B 8.D 9.B 10.A

11.C 12.A 13.D 14.A 15.B

16.A 17.A 18.A 19.C 20.D

二、填空题（每空1分，共20分）

评分标准：

总分20分。每答对1空，得1分；答错或不答均不得分。

7. 传地址

8. 指针P ； 指针p 指向的对象

9. 数据 ；函数

10. 友元函数

11. *(p->b) 或 *((*p).b)

12. 函数名

13. 共享

14. 多继承

15. 纯虚函数

16. 重载多态、强制多态、包含多态、参数多态 任意其中三个

17. 析构函数

18. 多继承机制

19. 友元函数；友元类

20. 直接基类指定；虚基类

三、判断题（每题1分，共10分）

1. 对 2. 错 3. 错 4. 错 5. 对 6. 对 7. 错 8. 对

四、读程填空、写出运行结果（每小题5分，共10分）

1．

new int(aa) ；delete a

2．

constructing B2：2

constructing B1：1

constructing B3*

constructing B1：3

constructing B2：4

constructing B3 *

五、简答题（每小题5分，共15分）

评分标准：

9. 错 10. 对

答案不完全，酌情扣分；答错或不答均不得分

1．所谓赋值兼容规则是指在公有派生情况下, 一个派生类的对象可以作为基类的对象来使用的地方。赋值兼容规则指的是下面三种情况：

(1) 派生的对象可以赋给基类的对象。

(2) 派生类的对象可以初始化基类的引用。

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

2．

答：两种情形，构造函数没有形参；构造函数有形参，但每一个形参都有缺省值。不能定义两个以上的缺省构造函数。

3．当对象含有指针数据成员，并用它初始化同类型的另一个对象时，缺省的拷贝构造函数

只能将该对象的数据成员复制给另一个对象，而不能将该对象中指针所指向的内存单元也复制过去。这样，就可能出现同一内存单元释放两次，导致程序运行出错。

六 编程题

1．评分标准：能体现用静态数据成员对象进行计数的酌情给分，不求程序形式的一致 参考程序

#include "iostream.h"

class ObjectCounter

{

private:

static int count;

//其他类成员的定义

public:

ObjectCounter()

{//其他代码

++count;

}

~ObjectCounter(){

--count;

//其他代码

}

ObjectCounter(ObjectCounter& a)

{

//其他代码

++count;

}

static int get_obeject_count(){return count;}

};

int ObjectCounter::count=0;

void main()

{

ObjectCounter o1;

cout

cout

cout

cout

cout

ObjectCounter *o2=new ObjectCounter();

cout

delete o2;

cout

ObjectCounter o3=ObjectCounter(o1);

cout

}

2．评分标准：根据程序的完整程度酌情给分

#include "iostream"

using namespace std;

class complex

{

public:

complex(double r=0,double i=0){real=r;image=i;}

void show(){cout

friend complex operator *(complex c1,complex c2);

private:

double real,image;

};

complex operator *(complex c1,complex c2)

{

double real=c1.real*c2.real-c1.image*c2.image;

double image=c1.real*c2.image+c1.image*c2.real;

return complex(real,image);

}

void main()

{

complex c1(1,2),c2(1,1);

c1.show();

c2.show();

complex c3=c1*c2;

c3.show();

}

3．评分标准：得分点：定义虚函数得三分，定义虚基类得三分，共8分

#include "iostream"

using namespace std;

class vehicle

{

public:

virtual void run(){}

virtual void stop(){}

};

class bicycle: virtual public vehicle

{

public:

void run(){cout

class motorcar: virtual public vehicle

{

public:

void run(){cout

class motorcycle:public bicycle,public motorcar {

public:

void run(){cout

void vehicle_drive(vehicle *pv)

{

pv->run();

pv->stop();

}

void main()

{

bicycle bicycle1;

motorcar motorcar1;

motorcycle motorcycle1;

vehicle *p=&bicycle1;

vehicle_drive(p);

p=&motorcar1;

vehicle_drive(p);

p=&motorcycle1;

vehicle_drive(p);

}