资源描述
习题四
填空题
1、联编是指一个程序模块、调用代码之间互相关联的过程。根据联编的时机不同，可以分为静态联编和（ 动态联编 ）。
2、包含一个或多个纯虚函数的类称为（抽象类 ）。
3、虚函数应该在（ 基类 ）中声明，且不能在派生类中重新定义。
4、纯虚函数是（ 只有函数声明而没有具体函数功能实现的虚函数）。
5、在析构函数前面加上关键字（ virtual）进行说明，称该析构函数为虚析构函数。
6、如果一个基类的析构函数被说明为虚析构函数，则它的派生类中的（析构函数 ）也是虚析构函数。
7、多态性分为两类：编译时的多态性和（ 运行时的多态性 ），编译时的多态性是通过和（ 函数 ）模板实现的。
8、对虚函数的调用有两种方式：（ 指针调用 ）和（ 对象调用 ）。
9、实现编译时的多态性的机制称为（静态关联 ），实现运行时的多态性的机制称为（ 动态关联 ）。
10、有一种特殊的虚函数，重定义时不要求同名，这种虚函数是（虚析构函数 ）。
11、模板可以实现程序设计中的（ 代码重用 ），体现了面向对象程序设计的（重用性 ）。
12、C++模板可以分为（ 函数模板 ）和（类模板 ）。
13、由函数模板实例化后是（ 模板函数 ），由类模板实例化后是（模板类 ）。
14、模板的声明使用关键字（template ）。
15、已知
int sum(int n){return n+n;}
long sum(long n){return n+n;}
是一个函数模板的两个实例，则该函数模板的定义是（ template<typename T>
T sum(T n){return n+n;} ）。
选择题
1、下面的4个关键字中，（ A ）是用来说明虚函数的。
A. virtual B. public C. protected D. 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. virtual int vf(int); B. void vf(int)=0;
C. virtual void vf()=0; D. virtual void vf(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. Aclass fun(int);
B. Aclass *p;
C. int fun(Aclass);
D. Aclass Obj;
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 <class T>
T func(T x,T y)
{return x+y;}
则对函数func调用不正确的是（ C ）。
A. func(3,5); B. func<>(3,5);
C. func(3,2.5); D. func<int>(3,2.5);
判断题
1、在C++中，要实现动态联编，可以使用基类指针调用虚函数。√
2、构造函数可以作为虚函数使用。N
3、虚函数是没有实现的函数。N
4、在派生类中，重载一个虚函数时，要求函数名、参数的个数、参数的类型、参数的顺序和函数返回值部分相同。N
5、抽象类是只有纯虚函数的类。N
6、构造函数可以作为虚函数。N
7、纯虚函数是一个特殊的虚函数，它没有具体的实现。√
8、虚函数的声明需要使用关键字protected。N
9、设置虚函数的目的是为了消除二义性。N
10、抽象类只能作为基类使用，其纯虚函数的实现由派生类来完成。√
分析题
1、
#include<iostream.h>
class A
{
public:
A()
{
cout<<endl<<"实例化类A的一个对象。";
}
virtual ~A()
{
cout<<endl<<"消除类A的一个对象。";
}
virtual void f()
{
cout<<endl<<"执行类A的成员函数。";
}
};
class B:public A
{
public:
B()
{
cout<<endl<<"实例化类B的一个对象。";
}
virtual ~B()
{
cout<<endl<<"消除类B的一个对象。";
}
void f()
{
cout<<endl<<"执行类B的成员函数。";
}
};
void main()
{
A a=A();
B b=B();
cout<<endl<<"----------";
a.f();
b.f();
cout<<endl<<"----------";
A *p;
p=&b;
p->f();
cout<<endl<<"----------";
}
2、
#include<iostream.h>
class shape
{
public:
shape(){};
virtual ~shape()
{
cout<<"Execting shape dtor"<<endl;
}
};
class Circle:public shape
{
public:
Circle(){};
~Circle()
{
cout<<"Execting Circle dtor"<<endl;
}
};
void main()
{
shape *pShape=new Circle;
delete pShape;
}
3、
#include <iostream>
using namespace std;
class Base
{
private: int x;
public: Base(int a=0) { x=a; }
virtual void fun() { cout<<"Base fun"<<endl; }
virtual ~Base() { cout<<"~Base"<<endl; }
};
class Derived:public Base
{
private: int y;
public: Derived(int a=0,int b=0):Base(a) { y=b; }
void fun() { cout<<"Derived fun"<<endl; }
~Derived() { cout<<"~Derived"<<endl; }
};
void GFun(Base *p)
{ p->fun(); }
int main()
{
Derived *p=new Derived;
GFun(p); delete p;
return 0;
}
4、
#include<iostream.h>
class Base
{
public:
virtual int func(){return 10;}
};
class Derived:public Base
{
public:
int func(){return 80;}
};
void main()
{
Derived d;
Base&b=d;
cout<<b.func()<<endl;
cout<<b.Base::func()<<endl;
}
5、
#include<iostream.h>
class base
{
public:
virtual void who(){cout<<"base class1"<<endl;}
};
class derive1:public base
{
public:
void who(){cout<<"derive1 class2"<<endl;}
};
class derive2:public base
{
public:
void who()
{cout<<"derive2 class3"<<endl;}
};
void main()
{
base obj1,*p;
derive1 obj2;
derive2 obj3;
p=&obj1;
p->who();
p=&obj2;
p->who();
p=&obj3;
p->who();
obj2.who();
obj3.who();
}
6、
#include<iostream>
#include<cstring>
using namespace std;
class Base{
char base_name[20];
public:
Base(){strcpy(base_name,"BASE");}
virtual char*my_name(){return base_name;}
char*class_name(){return base_name;}
};
class Derived:public Base{
char derived_name[20];
public:
Derived(){strcpy(derived_name,"DERIVED");}
char*my_name(){return derived_name;}
char*class_name(){return derived_name;}
};
void show_ptr(Base*p)
{
cout<<endl<<p->my_name()<<""<<p->class_name();
}
void show_ref(Base&r)
{
cout<<endl<<r.my_name()<<""<<r.class_name();;
}
int main()
{
Base bb;
Derived dd;
cout<<endl;
show_ptr(&bb);cout<<"<==应显示'ABCD EFG'";
show_ptr(&dd);cout<<"<==应显示'DERIVED EFG'";
cout<<endl;
show_ref(bb);cout<<"<==应显示'ABCD EFG'";
show_ref(dd);cout<<"<==应显示'DERIVED EFG'";
cout<<endl;
cout<<endl<<dd.Base::my_name()<<""<<dd.Base::class_name();
cout<<"<==应显示'ABCD EFG'";
return 0;
}
7、
#include<iostream.h>
#include<math.h>
const double PI=3.14;
class Circle
{
protected:
double r;
public:
Circle(double radius=0):r(radius){}
virtual double Area()=0 ;
virtual double Volume()=0;
};
class Sphere:public Circle
{
public:
Sphere(double radius=0):Circle(radius){}
double Area(){ return 4*PI*r*r;}
double Volume(){ return 4*PI*pow(r,3)/3; }
};
class Cylinder:public Circle
{
double h;
public:
Cylinder(double radius=0,double height=0):Circle(radius)
{ h=height; }
double Area(){ return 2*PI*r*(r+h); }
double Volume(){ return PI*r*r*h; }
};
class Cone:public Circle
{
double h;
public:
Cone(double radius=0,double height=0):Circle(radius)
{ h=height; }
double Area()
{
double l=sqrt(h*h+r*r);
return PI*r*r*(r+l);
}
double Volume()
{
return PI*r*r*h/3;
}
};
void Output(Circle*b[],int n)
{
for(int i=0;i<n;i++)
cout<<b[i]->Area()<<" "<<b[i]->Volume()<<endl;
}
void main()
{
Sphere r1(2);
Cylinder r2(2,3);
Cone r3(2,3);
Circle*a[3]={&r1,&r2,&r3};
Output(a,3);
}
8、
#include<iostream.h>
template <class T>
T min(T x,T y)
{
if (x<y)
return x;
else
return y;
}
void main()
{
int n1=2,n2=8;
double d1=2.3,d2=5.6;
cout<<min(n1,n2)<< " ";
cout<<min(d1,d2)<< endl;
}
9、
#include<iostream.h>
template <typename T>
T total(T *p)
{
T sum=0;
while(*p)
sum+=*p++;
return sum;
}
int main()
{
int x[]={1,3,5,7,9,0,13,15,17};
cout<<total(x);
return 0;
}
一、 编程题
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 <typename T>
T sum(T n){return n+n;}
二、 选择题
1、A 2、D 3、C 4、D 5、C 6、C 7、C 8、D 9、A 10、C
11、D 12、D 13、B 14、B 15、D 16、D 17、C 18、D 19、C 20、C
三、 判断题
1、√ 2、× 3、× 4、× 5、× 6、× 7、√ 8、× 9、× 10、√
四、 分析题
1、
实例化类A的一个对象。
实例化类A的一个对象。
实例化类B的一个对象。
----------
执行类A的成员函数。
执行类B的成员函数。
----------
执行类B的成员函数。
----------
消除类B的一个对象。
消除类A的一个对象。
消除类A的一个对象。
2、
Execting Circle dtor
Execting shape dtor
3、
Derived fun
~Derived
~Base
4、
80
10
5、
base class1
derive1 class2
derive2 class3
derive1 class2
derive2 class3
6、
BASEBASE<==应显示'ABCD EFG'
DERIVEDBASE<==应显示'DERIVED EFG'
BASEBASE<==应显示'ABCD EFG'
DERIVEDBASE<==应显示'DERIVED EFG'
BASEBASE<==应显示'ABCD EFG'
7、
50.24 33.4933
62.8 37.68
70.4057 12.56
8、
2 2.3
9、
25
五、编程题
1、
#include<iostream.h>
class RQ
{
public:
virtual float calTJ()=0;
virtual void display()=0;
};
class LFT:public RQ
{
private:
float A;
public:
LFT(float a){A=a;}
float calTJ(){return A*A*A;}
void display(){cout<<"立方体体积为"<<calTJ()<<endl;}
};
class CFT:public RQ
{
private:
float A,B,C;
public:
CFT(float a,float b,float c){A=a;B=b;C=c;}
float calTJ(){return A*B*C;}
void display(){cout<<"长方体体积为"<<calTJ()<<endl;}
};
void main()
{
RQ *p;
LFT L1(3);
CFT C1(1,2,3);
p=&L1;
p->display();
p=&C1;
p->display();
}
2、
#include<iostream.h>
class Employee
{
public:
virtual double earn()=0;
virtual void print()=0;
};
class Manager:public Employee
{
private:
double msalary;
public:
Manager(double ms){msalary=ms;}
double earn(){return msalary;}
void print(){cout<<"主管月工资为："<<earn()<<endl;}
};
class Hworker:public Employee
{
private:
double wage;
int hours;
public:
Hworker(double w,int h){wage=w;hours=h;}
double earn(){return 2500+hours*50;}
void print(){cout<<"员工加班"<<hours<<"小时工资为："<<earn()<<endl;}
};
void main()
{
Employee *p;
Manager m1(4200);
Hworker h1(2500,3);
p=&m1;
p->print();
p=&h1;
p->print();
}
3、
#include "iostream.h"
#include "math.h"
const double PI=3.14;
class Shape
{
public:
virtual void GetPerimeter()=0;
virtual void GetArea()=0;
protected:
double per;
double area;
};
class Circle:public Shape
{
double Radius;
public:
Circle(double r) { Radius=r; }
void GetPerimeter()
{
per=2*PI*Radius; cout<<"Circle's perimeter:"<<per<<endl;
}
void GetArea()
{
area=PI*Radius*Radius; cout<<"Cricle's area:"<<area<<endl;
}
};
class Square:public Shape
{
double length;
public:
Square(double l) { length=l; }
void GetPerimeter()
{
per=4*length; cout<<"Square's perimeter:"<<per<<endl;
}
void GetArea()
{
area=length*length; cout<<"Square's area:"<<area<<endl;
}
};
void main()
{
Shape *p;
Circle c(6);
Square s(7);
p=&c; p->GetPerimeter(); p->GetArea();
p=&s; p->GetPerimeter(); p->GetArea();
}
4、
#include<iostream.h>
template <typename T>
T min(T a,T b)
{
return a<b?a:b;
}
void main()
{
cout<<"min(3,4)="<<min(3,4)<<endl;
cout<<"min(3.5,4.5)="<<min(3.5,4.5)<<endl;
cout<<"min('a','b')="<<min('a','b')<<endl;
}
5、
#include<iostream.h>
template <typename T>
class input
{
public:
input()
{
cout<<"请输入数据(0-100)"<<endl;
cin>>a;
if(a<0||a>100)
{
cout<<"请重新输入"<<endl;
cin>>a;
}
}
private:T a;
};
void main()
{
input<int> a;
}
（此文档部分内容来源于网络，如有侵权请告知删除，文档可自行编辑修改内容，供参考，感谢您的配合和支持）
编辑版word
展开阅读全文
浙ICP备2021020529号-1 | 浙B2-20240490 
