c类和对象练习题修订稿.docx

c类和对象练习题修订稿.docx

《c类和对象练习题修订稿.docx》由会员分享，可在线阅读，更多相关《c类和对象练习题修订稿.docx（22页珍藏版）》请在冰豆网上搜索。

c类和对象练习题修订稿

公司标准化编码[QQX96QT-XQQB89Q8-NQQJ6Q8-MQM9N]

c类和对象练习题

第8章类与对象

8．1知识要点

1．掌握类与对象的概念和定义方法，掌握类成员的访问属性。

2．掌握构造函数的概念、定义方法和使用方法。

3．掌握析构函数的概念、定义方法和使用方法。

4．掌握拷贝构造函数的概念、定义方法和使用方法。

5．掌握包含对象成员的类构造函数的定义方法。

6．掌握静态成员的概念、定义方法、作用和特点。

7．掌握友元的概念、定义方法、作用和特点。

8．掌握类模板的定义格式与使用方法。

8．2典型例题分析与解答

例题1：

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

A．对象是类的一个实例

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

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

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．如果一个类中没有定义拷贝构造函数时，系统将自动生成一个默认的

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

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

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

答案：

D

分析：

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

?

例题6：

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

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

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

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

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

答案：

B

分析：

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

?

例题7：

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

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

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

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

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

{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,;

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

}

分析：

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

函数返回类型类名：

：

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

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

改正后的程序如下：

#include<>

classAmplifier

{floatinvol,outvol;

public:

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

floatgain（）;

};

floatAmplifier:

:

gain（）{returnoutvol/invol;}

voidmain（）

{Amplifieramp,;

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=;y=;

cout<<"callingthecopy_initializationconstructorfunction.\n";

}

pointmove（pointq）

{cout<<"OK!

\n";

inti,j;

i=+10;

j=+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）;

（）;

studentd2;

（）;

}

?

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

doubley=double（）（））;

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=doubledoubledy=doublereturnsqrt（dx*dx+dy*dy）;

}

voidmain（）

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

cout<<”Thedistanceis:

”<

}

8．3教材习题分析与解答

1．选择题

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

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

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

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

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

答案：

A

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

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

答案：

D

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

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

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

答案：

C

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

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

B.友元函数是类的成员

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

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

答案：

C

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

B.protected.static

答案：

C

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

B.protected.static

答案：

A

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

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

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

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

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

答案：

C

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

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

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

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

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

答案：

A

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;

（）;

}

运行结果为：

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

（）;

（）;

}

运行结果为：

Constructor1

Constructor2

i=-0

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;

（）;

（）;

}

运行结果为:

i=0,k=2

i=0,k=2

3．按要求编写程序。

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

classProduct

{char*name;是一种用户自定义的数据类型

B.只有类中的成员函数或类的友元函数才能存取类中的私有数据

C.在类中（用class定义），如果不作特别说明，所有的数据均为私有数据

D.在类中（用class定义），如果不作特别说明，所有的成员函数均为公有数据

（2）以下有关析构函数的叙述不正确的是（）

A.在一个类只能定义一个析构函数B.析构函数和构造函数一样可以有形参

C.析构函数不允许用返回值D.析构函数名前必须冠有符号“~”

（3）以下有关类与结构体的叙述不正确的是（）

A.结构体中只包含数据；类中封装了数据和操作

B.结构体的成员对外界通常是开放的；类的成员可以被隐藏

C.用struct不能声明一个类型名；而class可以声明一个类名

D.结构体成员默认为public；类成员默认为private

（4）以下叙述中不正确的是（）

A.一个类的所有对象都有各自的数据成员，它们共享函数成员

B.一个类中可以有多个同名的成员函数

C.一个类中可以有多个构造函数、多个析构函数

D.在一个类中可以声明另一个类的对象作为它的数据成员

（5）以下不属于构造函数特征的是（）

A.构造函数名与类名相同B.构造函数可以重载

C.构造函数可以设置默认参数D.构造函数必须指定函数类型

（6）以下有关类和对象的叙述不正确的是（）

A.任何一个对象都归属于一个具体的类

B.类与对象的关系和数据类型与变量的关系相似

C.类的数据成员不允许是另一个类的对象

D.一个类可以被实例化成多个对象

（7）设有定义：

classperson

{intnum;

charname[10];

public:

voidinit（intn,char*m）;

...

};

personstd[30];

则以下叙述不正确的是（）

A.std是一个含有３０个元素的对象数组

B.std数组中的每一个元素都是person类的对象

C.std数组中的每一个元素都有自己的私有变量num和name

D.std数组中的每一个元素都有各自的成员函数init

（8）设有以下类的定义：

classEx

{intx;

public:

voidsetx（intt=0）;

};

若在类外定义成员函数setx（）,以下定义形式中正确的是（）

A.voidsetx（intt）{...}

B.voidEx:

:

setx（intt）{...}

C.Ex:

:

voidsetx（intt）{...}

D.voidEx:

:

setx（）{...}

（9）以下关于静态成员变量的叙述不正确的是（）

A．静态成员变量为类的所有对