习题指导1类.docx

习题指导1类.docx

《习题指导1类.docx》由会员分享，可在线阅读，更多相关《习题指导1类.docx（18页珍藏版）》请在冰豆网上搜索。

习题指导1类

习题指导            类与对象

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；

           void  show（）{cout<

          }；                                   }

    C． classP{                       D.   classP{

          int  f;                             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（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=>"<

}

例题14：

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

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

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

程序代码如下：

#include

#include

class  student

{  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”<

”<

 else    cout<<”no”<

None!

\n”;

}

};

voidmain（）

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

d1.display（）;

studentd2;

d2.display（）;

}

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

1．  选择题

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

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

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

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

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.public     B.protected     C.private    D.static

答案：

C

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

        A.public     B.protected     C.private    D.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（）

{Point  a;}

运行结果为：

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

（5）编写一个程序计算两个给定的长方形的周长和面积。

#include

classrectangle

{   intlen,wid;

  public:

rectangle（inti=0,intj=0）

{len=i;wid=j;}

  friendintarea（rectangletemp）

{ints=temp.len*temp.wid;

      returns;

}

      friendfun（rectangletemp）

  {intp=2*（temp.len+temp.wid）;

      returnp;

}

};

voidmain（）

{  rectanglea（10,20）;

   cout<<"长方形的周长和面积为：

"<

   rectangleb（100,200）;

   cout<<"长方形的周长和面积为：

"<

}

8.4补充习题

2.填空题

（1）OOP技术由          、          、方法、消息和继承五个基本的概念所组成。

（2）    类的成员函数可以在               定义，也可以在                定义。

（3）    类test的析构函数名是               。

（4）    类是用户定义的类型，具有类类型的变量称作_______________。

（5）    一个类的析构函数不允许有                     。

（6）    建立对象时，为节省内存，系统只给_______分配内存。

（7）    用于定义C++的类的关键字有____________、___________和union。

（8）    类test的构造函数是和_______同名的函数，析构函数是__________。

（9）    类中的数据和成员函数默认访问类型为          。

（10）当建立一个新对象时，程序自动调用_______________。

3.改错题

（1） 下面的程序定义了一个Point类，找出程序中的错误语句并改正。

    #include

    classPoint{

          intx;

     public:

          voidPoint（inta）

         {x=a;}

          intGetx（）{returnx;}

          voidShow（）

         {cout<

  };

 voidmain（）

 {PointA（76）;

   cout<

 }

（2） 根据静态成员的特点，指出下列程序的错误。

#include

#include

classpart

{   public:

       Part（char*pname=”noname”）

       {strncpy（name,pname）;

         noofpart++;

         no=noofpart;

         cout<<”createtheno:

”<

        }

       ~Part（）

       {noofpart--;

         cout<<”destroytheno:

”<

        }

       staticintnumber（）{returnno;}

  protected:

       staticintnoofpart=0;

       intno;

       charname[40];

};

voidmain（）

{Partp1;

 Partp2;

}

（3）以下程序的功能是：

利用友员函数为类的成员变量进行初始化，然后利用成员函数输出。

请改正程序中的错误，使之能正确运行。

#include

classA

{  inta,b;

  public:

    friendvoidsetval（inti,intj）;

    voidshowA（）

    {cout<

};

voidsetval（inti,intj）

{a=i;b=j;}

voidmain（）

{Aobj1;

 setval（2,3）;

 obj1.showA（）;

}