C++谭浩强总复习题4.docx

C++谭浩强总复习题4.docx

《C++谭浩强总复习题4.docx》由会员分享，可在线阅读，更多相关《C++谭浩强总复习题4.docx（26页珍藏版）》请在冰豆网上搜索。

C++谭浩强总复习题4

习题四

填空题

1、联编是指一个程序模块、调用代码之间互相关联的过程。

根据联编的时机不同，可以分为静态联编和（动态联编）。

2、包含一个或多个纯虚函数的类称为（抽象类）。

3、虚函数应该在（基类）中声明，且不能在派生类中重新定义。

4、纯虚函数是（只有函数声明而没有具体函数功能实现的虚函数）。

5、在析构函数前面加上关键字（virtual）进行说明，称该析构函数为虚析构函数。

6、如果一个基类的析构函数被说明为虚析构函数，则它的派生类中的（析构函数）也是虚析构函数。

7、多态性分为两类：

编译时的多态性和（运行时的多态性），编译时的多态性是通过和（函数）模板实现的。

8、对虚函数的调用有两种方式：

（指针调用）和（对象调用）。

9、实现编译时的多态性的机制称为（静态关联），实现运行时的多态性的机制称为（动态关联）。

10、有一种特殊的虚函数，重定义时不要求同名，这种虚函数是（虚析构函数）。

11、模板可以实现程序设计中的（代码重用），体现了面向对象程序设计的（重用性）。

12、C++模板可以分为（函数模板）和（类模板）。

13、由函数模板实例化后是（模板函数），由类模板实例化后是（模板类）。

14、模板的声明使用关键字（template）。

15、已知

intsum（intn）{returnn+n;}

longsum（longn）{returnn+n;}

是一个函数模板的两个实例，则该函数模板的定义是（template

Tsum（Tn）{returnn+n;}）。

选择题

1、下面的4个关键字中，（A）是用来说明虚函数的。

A.virtualB.publicC.protectedD.private

2、实现运行时的多态性要使用（D）。

A.重载函数B.构造函数C.析构函数D.虚函数

3、如果一个类至少有一个纯虚函数，那么该类称为（C）。

A.虚基类B.派生类C.抽象类D.以上都不对

4、下列描述中，（D）是抽象类的特征。

A.可以说明虚函数

B.可以进行构造函数重载

C.可以定义友元

D.不能说明其对象

5、下列关于虚函数的描述中，（C）是正确的。

A.虚函数是一个非成员函数

B.虚函数是一个静态成员函数

C.派生类的虚函数与基类种对应的虚函数具有相同的参数个数和类型

D.虚函数既可以在函数说明时定义，也可以在函数实现时定义

6、下列关于纯虚函数与抽象类的描述中，（C）是错误的。

A.抽象类是指具有纯虚函数的类

B.纯虚函数是一个特殊的虚函数，它没有具体的实现

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

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

7、下列各函数的说明中，（B）表示纯虚函数。

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

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

8、虚函数必须是类的（D）。

A.友元函数B.构造函数C.析构函数D.成员函数

9、下列关于虚函数的描述中，（A）是正确的。

A.虚函数不能声明为另一个类的友元函数

B.虚函数不能声明为静态成员函数

C.派生类必须重新定义基类的虚函数

D.如果在重定义虚函数时使用了保留字virtual，则该重定义函数仍然是虚函数

10、多态调用是指（C）。

A.以任何方式调用一个虚函数

B.以任何方式调用一个纯虚函数

C.借助于指向对象的基类指针或引用调用一个虚函数

D.借助于指向对象的基类指针或引用调用一个纯虚函数

11、在C++中，要实现动态联编，必须使用（D）调用虚函数。

A.类名

B.派生类指针

C.对象名

D.基类指针

12、下列函数中，可以作为虚函数的是（D）。

A.普通函数

B.构造函数

C.友元函数

D.析构函数

13、在派生类中，重载一个虚函数时，要求函数名、参数的个数、参数的类型、参数的顺序和函数返回值（B）。

A.不同

B.相同

C.相容

D.部分相同

14、假设Aclass为抽象类，下列声明（B）是正确的。

A.Aclassfun（int）;

B.Aclass*p;

C.intfun（Aclass）;

D.AclassObj;

15、下面描述中，正确的是（D）。

A.虚函数是没有实现的函数

B.纯虚函数的实现只能在直接派生类中定义

C.抽象类是只有纯虚函数的类

D.抽象类指针可以指向不同的派生类

16、当运行程序时实际上是将类模板实例化为一个具体的（D）。

A.类B.对象C.函数D.模板类

17、模板函数的真正代码是在（C）时产生的。

A.源程序中声明函数时B.源程序中定义函数时

C.源程序中调用函数时D.运行执行函数时

18、类模板的模板参数（D）。

A.只可作为数据成员的类型B.只可作为成员的返回值类型

C.只可作为成员函数的参数类型D.以上三者皆可

19、以下关于模板的叙述中，不正确的是（C）。

A.用模板定义一个对象时不能省略参数

B.类模板只能有虚拟参数类型

C.类模板的成员函数都是模板函数

D.类模板本身在编译中不会生成任何代码

20、如果有如下函数模板的定义：

template

Tfunc（Tx,Ty）

{returnx+y;}

则对函数func调用不正确的是（C）。

A.func（3,5）;B.func<>（3,5）;

C.func（3,2.5）;D.func（3,2.5）;

判断题

1、在C++中，要实现动态联编，可以使用基类指针调用虚函数。

√

2、构造函数可以作为虚函数使用。

N

3、虚函数是没有实现的函数。

N

4、在派生类中，重载一个虚函数时，要求函数名、参数的个数、参数的类型、参数的顺序和函数返回值部分相同。

N

5、抽象类是只有纯虚函数的类。

N

6、构造函数可以作为虚函数。

N

7、纯虚函数是一个特殊的虚函数，它没有具体的实现。

√

8、虚函数的声明需要使用关键字protected。

N

9、设置虚函数的目的是为了消除二义性。

N

10、抽象类只能作为基类使用，其纯虚函数的实现由派生类来完成。

√

分析题

1、

#include

classA

{

public:

A（）

{

cout<

";

}

virtual~A（）

{

cout<

";

}

virtualvoidf（）

{

cout<

";

}

};

classB:

publicA

{

public:

B（）

{

cout<

";

}

virtual~B（）

{

cout<

";

}

voidf（）

{

cout<

";

}

};

voidmain（）

{

Aa=A（）;

Bb=B（）;

cout<

a.f（）;

b.f（）;

cout<

A*p;

p=&b;

p->f（）;

cout<

}

2、

#include

classshape

{

public:

shape（）{};

virtual~shape（）

{

cout<<"Exectingshapedtor"<

}

};

classCircle:

publicshape

{

public:

Circle（）{};

~Circle（）

{

cout<<"ExectingCircledtor"<

}

};

voidmain（）

{

shape*pShape=newCircle;

deletepShape;

}

3、

#include

usingnamespacestd;

classBase

{

private:

intx;

public:

Base（inta=0）{x=a;}

virtualvoidfun（）{cout<<"Basefun"<

virtual~Base（）{cout<<"~Base"<

};

classDerived:

publicBase

{

private:

inty;

public:

Derived（inta=0,intb=0）:

Base（a）{y=b;}

voidfun（）{cout<<"Derivedfun"<

~Derived（）{cout<<"~Derived"<

};

voidGFun（Base*p）

{p->fun（）;}

intmain（）

{

Derived*p=newDerived;

GFun（p）;deletep;

return0;

}

4、

#include

classBase

{

public:

virtualintfunc（）{return10;}

};

classDerived:

publicBase

{

public:

intfunc（）{return80;}

};

voidmain（）

{

Derivedd;

Base&b=d;

cout<

cout<

:

func（）<

}

5、

#include

classbase

{

public:

virtualvoidwho（）{cout<<"baseclass1"<

};

classderive1:

publicbase

{

public:

voidwho（）{cout<<"derive1class2"<

};

classderive2:

publicbase

{

public:

voidwho（）

{cout<<"derive2class3"<

};

voidmain（）

{

baseobj1,*p;

derive1obj2;

derive2obj3;

p=&obj1;

p->who（）;

p=&obj2;

p->who（）;

p=&obj3;

p->who（）;

obj2.who（）;

obj3.who（）;

}

6、

#include

#include

usingnamespacestd;

classBase{

charbase_name[20];

public:

Base（）{strcpy（base_name,"BASE"）;}

virtualchar*my_name（）{returnbase_name;}

char*class_name（）{returnbase_name;}

};

classDerived:

publicBase{

charderived_name[20];

public:

Derived（）{strcpy（derived_name,"DERIVED"）;}

char*my_name（）{returnderived_name;}

char*class_name（）{returnderived_name;}

};

voidshow_ptr（Base*p）

{

cout<my_name（）<<""<class_name（）;

}

voidshow_ref（Base&r）

{

cout<

}

intmain（）

{

Basebb;

Deriveddd;

cout<

show_ptr（&bb）;cout<<"<==应显示'ABCDEFG'";

show_ptr（&dd）;cout<<"<==应显示'DERIVEDEFG'";

cout<

show_ref（bb）;cout<<"<==应显示'ABCDEFG'";

show_ref（dd）;cout<<"<==应显示'DERIVEDEFG'";

cout<

cout<

:

my_name（）<<""<

:

class_name（）;

cout<<"<==应显示'ABCDEFG'";

return0;

}

7、

#include

#include

constdoublePI=3.14;

classCircle

{

protected:

doubler;

public:

Circle（doubleradius=0）:

r（radius）{}

virtualdoubleArea（）=0;

virtualdoubleVolume（）=0;

};

classSphere:

publicCircle

{

public:

Sphere（doubleradius=0）:

Circle（radius）{}

doubleArea（）{return4*PI*r*r;}

doubleVolume（）{return4*PI*pow（r,3）/3;}

};

classCylinder:

publicCircle

{

doubleh;

public:

Cylinder（doubleradius=0,doubleheight=0）:

Circle（radius）

{h=height;}

doubleArea（）{return2*PI*r*（r+h）;}

doubleVolume（）{returnPI*r*r*h;}

};

classCone:

publicCircle

{

doubleh;

public:

Cone（doubleradius=0,doubleheight=0）:

Circle（radius）

{h=height;}

doubleArea（）

{

doublel=sqrt（h*h+r*r）;

returnPI*r*r*（r+l）;

}

doubleVolume（）

{

returnPI*r*r*h/3;

}

};

voidOutput（Circle*b[],intn）

{

for（inti=0;i

cout<Area（）<<""<Volume（）<

}

voidmain（）

{

Spherer1

（2）;

Cylinderr2（2,3）;

Coner3（2,3）;

Circle*a[3]={&r1,&r2,&r3};

Output（a,3）;

}

8、

#include

template

Tmin（Tx,Ty）

{

if（x

returnx;

else

returny;

}

voidmain（）

{

intn1=2,n2=8;

doubled1=2.3,d2=5.6;

cout<

cout<

}

9、

#include

template

Ttotal（T*p）

{

Tsum=0;

while（*p）

sum+=*p++;

returnsum;

}

intmain（）

{

intx[]={1,3,5,7,9,0,13,15,17};

cout<

return0;

}

一、编程题

1、生成容器类RQ，提供成员函数calTJ（）计算容器的体积，定义calTJ（）为纯虚数，生成LFT类表示立方体，数据成员A表示立方体的边长，提供成员函数calTJ（）计算立方体的体积；生成长方体类CFT，数据成员A,B,C分别表示长方体的长，宽和高，提供成员函数calTJ（）计算长方体的体积，类CFT和类LFT都继承类RQ。

2、在一个公司里，主管和员工的月工资计算方法规定如下：

主管的每月工资固定为4200元；员工的每月工资与加班的时间有关，计算方法是每加班一小时50元，固定工资为2500元。

编程实现每个人的月工资。

要求利用纯虚函数实现。

3、编程计算圆形（Circle）和正方形（Square）的周长和面积。

要求定义一个抽象类，其中包括求周长（per）和面积（area）的纯虚函数，然后在此基类的基础上，派生出圆形类和正方形类，主函数通过基类的指针调用各派生类的函数。

4、用函数模板实现求两个整数、两个浮点数和两个字符中的最小值。

5、定义一个类模板input，在调用构造函数时，完成的工作包括：

提示用户输入；让用户输入数据；如果用户输出数据不在预定范围内，提示重新输入。

习题答案

一、填空题

1、动态联编

2、抽象类

3、基类

4、只有函数声明而没有具体函数功能实现的虚函数。

5、virtual

6、析构函数

7、运行时的多态性，函数

8、指针调用，对象调用

9、静态联编，动态联编

10、虚析构函数

11、代码重用，可重用性

12、函数模板，类模板

13、模板函数，模板类

14、template

15、template

Tsum（Tn）{returnn+n;}

二、选择题

1、A2、D3、C4、D5、C6、C7、C8、D9、A10、C

11、D12、D13、B14、B15、D16、D17、C18、D19、C20、C

三、判断题

1、√2、×3、×4、×5、×6、×7、√8、×9、×10、√

四、分析题

1、

实例化类A的一个对象。

实例化类A的一个对象。

实例化类B的一个对象。

----------

执行类A的成员函数。

执行类B的成员函数。

----------

执行类B的成员函数。

----------

消除类B的一个对象。

消除类A的一个对象。

消除类A的一个对象。

2、

ExectingCircledtor

Exectingshapedtor

3、

Derivedfun

~Derived

~Base

4、

80

10

5、

baseclass1

derive1class2

derive2class3

derive1class2

derive2class3

6、

BASEBASE<==应显示'ABCDEFG'

DERIVEDBASE<==应显示'DERIVEDEFG'

BASEBASE<==应显示'ABCDEFG'

DERIVEDBASE<==应显示'DERIVEDEFG'

BASEBASE<==应显示'ABCDEFG'

7、

50.2433.4933

62.837.68

70.405712.56

8、

22.3

9、

25

五、编程题

1、

#include

classRQ

{

public:

virtualfloatcalTJ（）=0;

virtualvoiddisplay（）=0;

};

classLFT:

publicRQ

{

private:

floatA;

public:

LFT（floata）{A=a;}

floatcalTJ（）{returnA*A*A;}

voiddisplay（）{cout<<"立方体体积为"<

};

classCFT:

publicRQ

{

private:

floatA,B,C;

public:

CFT（floata,floatb,floatc）{A=a;B=b;C=c;}

floatcalTJ（）{returnA*B*C;}

voiddisplay（）{cout<<"长方体体积为"<

};

voidmain（）

{

RQ*p;

LFTL1（3）;

CFTC1（1,2,3）;

p=&L1;

p->display（）;

p=&C1;

p->display（）;

}

2、

#include

classEmployee

{

public:

virtualdoubleearn（）=0;

virtualvoidprint（）=0;

};

classManager:

publicEmployee

{

private:

doublemsalary;

public:

Manager（doublems）{msalary=ms;}

doubleearn（）{returnmsalary;}

voidprint（）{cout<<"主管月工资为：

"<

};

classHworker:

publicEmployee

{

private:

doublewage;

inthours;

public:

Hworker（doublew,inth）{wage=w;hours=h;}

doubleearn（）{return2500+hours*50;}

voidprint（）{cout<<"员工加班"<

"<

};

voidmain（）

{

Employee*p;

Managerm1（4200）;

Hwor