面向对象习题.docx

面向对象习题.docx

《面向对象习题.docx》由会员分享，可在线阅读，更多相关《面向对象习题.docx（86页珍藏版）》请在冰点文库上搜索。

面向对象习题

类与对象

例题1：

下列有关类的说法不正确的是（）。

A．A． 对象是类的一个实例

B．B． 任何一个对象只能属于一个具体的类

C．C． 一个类只能有一个对象

D．D．类与对象的关系和数据类型与变量的关系相似

答案：

C

分析：

对象是类的一个实例，类与对象的关系和数据与变量的关系相似，所以一个类可以有多个对象。

例题2：

下面（）项是对构造函数和析构函数的正确定义。

A．voidX:

:

X（）,voidX:

:

~X（）

B．X:

:

X（参数）,X:

:

~X（）

C．X:

:

X（参数）,X:

:

~X（参数）

D．voidX:

:

X（参数）,voidX:

:

~X（参数）

答案：

B

分析构造函数无返回类型、可带参数、可重载；析构函数无返回类型、不可带参数、不可重载。

例题3：

（）的功能是对象进行初始化。

A．析构函数B.数据成员C.构造函数D.静态成员函数

答案：

C

分析：

当一个对象定义时，C++编译系统自动调用构造函数建立该对象并进行初始化；当一个对象的生命周期结束时，C++编译系统自动调用析构函数注销该对象并进行善后工作；

例题4：

下列表达方式正确的是（）。

A．classP{B．classP{

public：

public：

intx=15；intx；

voidshow（）{cout<

}；}

C．classP{D.classP{

intf;public：

}；inta；

f=25；voidSeta（intx）{a=x;}

答案：

D

分析：

在类体内不可对数据成员进行初始化（从类对象区别于其数据成员解释）；类定义结束时需用分号；只有类中的成员函数才能存取类中的私有数据。

例题5：

拷贝构造函数具有的下列特点中，（）是错误的。

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

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

C．C． 拷贝构造函数是一种成员函数

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

答案：

D

分析：

如果一个类中没有定义拷贝构造函数时，系统将自动生成一个默认的；拷贝构造函数只有一个参数，并且是该类对象的引用；拷贝构造函数的名字与类同名，并且不被指定返回类型；拷贝构造函数是一种成员函数。

例题6：

关于静态成员的描述中，（）是错误的。

A．A． 静态成员可分为静态数据成员和静态成员函数

B．B． 静态数据成员定义后必须在类体内进行初始化

C．C． 静态数据成员初始化不使用其构造函数

D．D． 静态数据成员函数中不能直接引用非静态成员

答案：

B

分析：

静态成员可分为静态数据成员和静态成员函数；静态数据成员被定义后，必须对它进行初始化，初始化在类体外进行，一般放在该类的实现部分最合适，也可以放在其他位置，例如，放在主函数前面等；静态数据成员初始化与该类的构造函数和析构函数无关；在静态成员函数的实现中，可以直接引用静态成员，但不能直接引用非静态成员。

例题7：

关于友元的描述中，（）是错误的。

A．A． 友元函数是成员函数，它被说明在类体内

B．B．  友元函数可直接访问类中的私有成员

C．C．  友元函数破坏封装性，使用时尽量少用

D．D．  友元类中的所有成员函数都是友元函数

答案：

A

分析：

友元函数是非成员函数，在类体内说明了，在类体外定义，定义和调用等同于一般的普通函数；由于它可以直接访问类的私有成员，因此破坏了类的封装性和隐藏性，尽量少用。

例题8：

设有如下程序结构：

classBox

{…};

voidmain（）

{BoxA,B,C;}

该程序运行时调用

（1）次构造函数；调用

（2）次析构函数。

答案：

（1）3

（2）3

分析：

每创建一个对象自动调用一次构造函数，在这里创建了A、B、C三个对象，所以共调用了三次构造函数；每释放一个对象，系统自动调用一次析构函数，A、B、C对象释放时，分别调用析构函数，所以析构函数共调用了三次。

例题9：

设A为test类的对象且赋有初值,则语句testB（A）;表示。

答案：

将对象A复制给对象B。

分析：

执行testB（A）;语句相当于调用了默认复制构造函数，将A对象的属性复制给B对象。

例题10：

利用“对象名.成员变量”形式访问的对象成员仅限于被声明为

（1）的成员；若要访问其他成员变量，需要通过

（2）函数或（3）函数。

答案：

（1）public

（2）成员函数（3）友元函数

分析：

类体内的数据成员可声明为公有的、私有的和保护的，公有的数据成员可利用“对象名.成员变量”形式来进行访问；私有的数据成员能被类中的其他成员函数或友元函数所调用；保护的数据成员可以在类体中使用，也可以在派生类中使用，但不能在其他类外通过对象使用。

例题11：

分析找出以下程序中的错误，说明错误原因，给出修改方案使之能正确运行。

#include

classone

{

private:

inta1,a2;

public:

one（intx1=0,x2=0）;

};

voidmain（）

{onedata（2,3）;

cout<

cout<

}

分析：

出错原因：

构造函数参数表语法错；构造函数没有函数体；类的对象不能直接访问类的私有成员变量。

改正后的程序如下：

#include

classone

{inta1,a2;

public:

one（intx1=0,intx2=0）{a1=x1;a2=x2;}

intgeta1（）{returna1;}

intgeta2（）{returna2;}

};

voidmain（）

{onedata（2,3）;

cout<

cout<

}

例题12：

分析以下程序的错误原因，给出修改方案使之能正确运行。

#include

classAmplifier{

floatinvol,outvol;

public:

Amplifier（floatvin,floatvout）

{invol=vin;outvol=vout;}

floatgain（）;

};

Amplifier:

:

floatgain（）{returnoutvol/invol;}

voidmain（）

{Amplifieramp（5.0,10.0）;

cout<<"\n\nThegainis=>"<

}

分析：

成员函数在类体外定义格式是：

函数返回类型类名：

：

成员函数名（参数表）；成员函数调用格式是：

对象名.成员函数名（参数表）。

改正后的程序如下：

#include

classAmplifier

{floatinvol,outvol;

public:

Amplifier（floatvin,floatvout）{invol=vin;outvol=vout;}

floatgain（）;

};

floatAmplifier:

:

gain（）{returnoutvol/invol;}

voidmain（）

{Amplifieramp（5.0,10.0）;

cout<<"\n\nThegainis=>"<

}

例题13：

下列程序的运行结果是。

#include

classpoint

{intx,y;

public:

point（inta,intb）

{x=a;y=b;

cout<<"callingtheconstructorfunction."<

}

point（point&p）;

friendpointmove（pointq）;

~point（）{cout<<"callingthedestructorfunction.\n";}

intgetx（）{returnx;}

intgety（）{returny;}

};

point:

:

point（point&p）

{x=p.x;y=p.y;

cout<<"callingthecopy_initializationconstructorfunction.\n";

}

pointmove（pointq）

{cout<<"OK!

\n";

inti,j;

i=q.x+10;

j=q.y+20;

pointr（i,j）;

returnr;

}

voidmain（）

{pointm（15,40）,p（0,0）;

pointn（m）;

p=move（n）;

cout<<"p="<

}

分析：

根据构造函数、拷贝构造函数和友元函数的特点，执行该程序后，输出结果是：

callingtheconstructorfunction.

callingtheconstructorfunction.

callingthecopy_initializationconstructorfunction.

callingthecopy_initializationconstructorfunction.

OK！

callingtheconstructorfunction.

callingthecopy_initializationconstructorfunction.

callingthedestructorfunction.

callingthedestructorfunction.

callingthedestructorfunction.

P=25,60

callingthedestructorfunction.

callingthedestructorfunction.

callingthedestructorfunction.

说明：

（1）构造函数执行三次，分别初始化主函数中的对象m，p和move函数中的对象r。

（2）拷贝构造函数共执行了三次。

第一次，初始化对象n；第二次在调用函数move（）时，实参n给形参q进行初始化；第三次是执行函数move的returnr；语句时，系统用r初始化一个匿名对象时使用了拷贝构造函数。

（3）析构函数执行了六次。

在退出函数move时释放对象r和q共调用二次；返回主函数后，匿名对象赋值给对象p后，释放匿名对象又调用一次析构函数；最后退出整个程序时释放对象m，n和p调用三次。

例题14：

定义一个学生类，其中有3个数据成员：

学号、姓名、年龄，以及若干成员函数。

同时编写main函数使用这个类，实现对学生数据的赋值和输出。

程序代码如下：

#include

#include

classstudent

{intno;

charname[10];

intage;

public:

student（inti,char*str,intg）

{no=i;

strcpy（name,str）;

age=g;

}

student（）

{no=0;

strcpy（name,”none”）;

age=-1;

}

voiddisplay（）

{if（no>0）cout<<”no”<

”<

elsecout<<”no”<

None!

\n”;

}

};

voidmain（）

{studentd1（1001,”Tom”,18）;

d1.display（）;

studentd2;

d2.display（）;

}

例题15：

计算两点之间的距离。

方法一：

可以定义点类（Point），再定义一个类（Distance）描述两点之间的距离，其数据成员为两个点类对象，两点之间距离的计算可设计由构造函数来实现。

#include

#include

classPoint

{public:

Point（inta=0,intb=0）{x=a;y=b;}

intxcord（）{returnx;}

intycord（）{returny;}

private:

intx,y;

};

classDistance

{public:

Distance（Pointq1,Pointq2）;

doublegetdist（）{returndist;}

private:

Pointp1,p2;

doubledist;

};

Distance:

:

Distance（Pointq1,Pointq2）:

p1（q1）,p2（q2）

{doublex=double（p1.xcord（）-p2.xcord（））;

doubley=double（p1.ycord（）-p2.ycord（））;

dist=sqrt（x*x+y*y）;

}

voidmain（）

{Pointp（0,0）,q（1,1）;

Distancedis（p,q）;

cout<<”Thedistanceis:

”<

}

方法2：

将两点之间距离函数声明为Point类的友元函数。

#include

#include

classPoint

{public:

Point（inta=0,intb=0）{x=a;y=b;}

intxcord（）{returnx;}

intycord（）{returny;}

private:

intx,y;

frienddoubleDistance（Pointp1,Pointp2）;

};

doubleDistance（Pointp1,Pointp2）

{doubledx=double（p1.x-p2.x）;

doubledy=double（p1.y-p2.y）;

returnsqrt（dx*dx+dy*dy）;

}

voidmain（）

{Pointq1（0,0）,q2（1,1）;

cout<<”Thedistanceis:

”<

}

1． 选择题

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

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

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

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

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

答案：

A

（2）类的析构函数的作用是（D）。

A.一般成员函数B.类的初始化C.对象初始化D.删除对象

答案：

D

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

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

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

答案：

C

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

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

B.友元函数是类的成员

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

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

答案：

C

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

A.publicB.protectedC.privateD.static

答案：

A

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

A.publicB.protectedC.privateD.static

答案：

A

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

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

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

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

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

答案：

C

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

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

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

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

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

答案：

A

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

（1）#include

classPoint{

intx,y;

public:

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

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

};

voidmain（）

{Pointa;}

运行结果为：

Point1,1isdeleted.

（2）#include

#include

intcount=0;

classPoint

{intx,y;

public:

Point（）

{x=1;y=1;

count++;

}

~Point（）{count--;}

friendvoiddisplay（）;

}；

voiddisplay（）{cout<<"Thereare"<

voidmain（）

{Pointa;

display（）;

{Pointb[5];

display（）;

}

display（）;

}

运行结果为：

Thereare1points,

Thereare6points,

Thereare1points,

（3）#include

classCsample

{inti;

public:

Csample（）;

voidDisplay（）;

~Csample（）;

};

Csample:

:

Csample（）

{cout<<”Constructor”<<”,”;

i=0;

}

voidCsample:

:

Display（）{cout<<”i=”<

Csample:

:

~Csample（）

{cout<<”Destructor”<

voidmain（）

{Csamplea;

a.Display（）;

}

运行结果为：

Constructor,i=0,Destructor

（4）#include

#include

classCsample

{inti;

public:

Csample（）{cout<<"constructor1"<

Csample（intval）{cout<<"Constructor2"<

voidDisplay（）

{cout<<"i="<

~Csample（）

{cout<<"Destructor"<

};

voidmain（）

{Csamplea,b（10）;

a.Display（）;

b.Display（）;

}

运行结果为：

Constructor1

Constructor2

i=-858993460

i=10

Destructor

Destructor

（5）#include

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（）;

}

运行结果为:

i=0,k=2

i=0,k=2

3．按要求编写程序。

（1）编写一个程序，设计一个产品类Product,其定义如下：

classProduct

{char*name;//产品名称

intprice;//产品单价

intquantity；//剩余产品数量

public:

product（char*n,intpintq）;//构造函数

~product（）;//析构函数

voidbuy（intmoney）;//购买产品

voidget（）const;//显示剩余产品数量

};

并用数据进行测试。

（3）定义盒子Box类，要求具有以下成员：

可设置盒子形状；可计算盒子体积；可计算盒子的表面积。

#include

classBox

{intx,y,z;intv,s;

public:

voidinit（intx1=0,inty1=0,intz1=0）{x=x1;y=y1;z=z1;}

voidvolue（）{v=x*y*z;}

voidarea（）{s=2*（x*y+x*z+y*z）;}

voidshow（）

{cout<<"x="<

cout<<"s="<

}

};

voidmain（）

{Boxa;

a.init（2,3,4）;

a.volue（）;

a.area（）;

a.show（）;

}

（4）定义计数器类Counter。

要求具有以下成员：

计数器值；可进行增值和减值记数；可提供记数值。

#include

classCounter

{intn;

public:

Counter（inti=0）{n=i;}

voidinit_Counter（intm）{n=m;}