8．3 练习题解答
1．什么是多态性?为什么说它是面向对象程序设计的一个重要机制?
答：多态性是指同名函数对应多种不同的实现。多态性表现在重载和覆盖两种方
式。重载方式是指函数重载和运算符重载；覆盖方式是指不同类中定义的说明完全相同
的函数，这里有静态选择和动态选择两种机制。
多态性是在封装性和继承性基础上的面向对象程序设计语言的又一重要特性。这一
特性利用“重名”现象来提高程序的抽象度和简洁性，并给编程带来了灵活性。
2．函数重载的含义是什么?定义重载函数时应注意些什么问题?
答：函数重载是指相同的函数名对应着不同的实现。选择函数实现时根据函数的参
数类型、个数以及顺序的不同进行选取。因此，在定义重载函数时，一定要在参数的类型、个数和顺序上有所区别，否则编译时将无法选择。
3．运算符重载的含义是什么?是否所有的运算符都可以重载?
答：运算符重载是指在已定义运算符的基础上，通过重载来增加运算符的新功能。
例如，加法运算符十，它可以对整型数、浮点型数、字符型加整型数进行求和运算。但是，它不能对复数求和，如果仍要用加法运算符十对复数求和，这时需要对加法运算符进行重载，增加它对复数求和的功能。
C＋十语言中大多数运算符都可以根据需要进行重载。只有少数运算符不能重载，它
们是．，·*，：：，?：。
4．运算符重载有哪两种形式?这两种形式有何区别?
答：运算符重载有两种形式。一种是成员函数形式，另一种是友元函数形式。这两
种形式的共同特点是都可以直接对私有成员进行操作。这两种形式的区别主要表现在定
义格式上不同。使用成员函数形式时，对单目运算符没有参数；对于双目运算符，则仅有一个参数，因为引用该运算符重载的成员函数的对象将是第一操作数。使用友元函数形
式时，对单目运算符时，则有一个参数；对双目运算符时，则有两个参数，这里的参数便是重载运算符的操作数。另外，有些运算符使用成员函数较好，例如。单目运算符。有些运算符使用友元函数较好，例如，双目运算符。有些运算符两种都可以。
5．运算符重载函数使用关键字const说明后，是指什么不可改变?
答：运算符重载函数被说明为const时．表明该重载函数对被操作的对象状态不能被改变。
6．静态联编和动态联编的区别是什么?
答：不同类体中的相同说明的函数有着不同的实现。它们选择的方法分为两种情况，一种是在编译时选择，称为静态联编；另一种是在运行时选择，称为动态联编。这两种联编的方法主要区别在于选择函数不同实现的时间不同。
7．什么是虚函数?为什么要定义虚函数?它与动态联编有何关系?
答：虚函数是一种非静态的成员函数，说明虚函数的方法是在非静态的成员函数名
前加说明符virtual。
如果某类体中定义有虚函数就意味着在其派生类中有着不同的实现。定义虚函数的
目的是为了对于不同类体内相同说明的函数进行运行时选择，即动态联编。虚函数是动
态联编的一个重要条件。
8．什么是纯虚函数?什么是抽象类?
答：纯虚函数是一种不可实现的虚函数。该函数的实现要在该类的派生类或派生类
的派生类中体现。具有纯虚函数的类称为抽象类。抽象类是一种特殊的类，该类不能定
义其对象。抽象类的主要作用是将为继承层次结构中提供一个公共的根，相关于类将从
这个根派生出来。
9．虚析构函数有什么作用?
答：在具有动态联编的程序中，通常将析构函数前边加上关键字virtual，将它说明为虚析构函数，其目的是在于使用delete运算符删除一个对象时，确保析构函数被正确执行，即让析构工作彻底完成。
10．总结C++语言的多态性包含哪些内容?
答：C十十语言多态性所包含的内容总结如下：
(1)重载方式的多态性表现在函数重载和运算符重载方面。即同一个函数或同一个
运算符对应着不同的实现或功能。它们的选择将取决于函数参数的类型、个数及顺序的
不同或者操作数的类型的不同。重载方式主要是指同一类体中出现的相同函数名或运算符。
(2)覆盖方式的多态性表现在继承关系的不同类中出现的说明完全相同而实现不同的函数数，其中虚函数便是一种。对于这类函数的选择分为静态联编和动态联编两种，也可以用名字限定法来选择。
8．4 作业题解答
一、选择填空
1.对定义重载函数的下列要求中。( )是错误的
A．要求参数的个数不同
B．要求参数中至少有一个类型不同
C．要求参数个数相同时,参数类型不同
D．要求函数的返回值不同
答：D
2.下列函数中，( ) 不能重载。
A．成员函数
B．非成员函数
C．析构函数
D．构造函数
答：C。
3．下列对重载函数的描述中，( )是错误的。
A．重载函数中不允许使用默认参数
B．重载函数中编译系根据参数表进行选择
C．不要使用重载函数来描述毫无相干的函数
D．构造函数重载将会给初始化带来多种方式
答：A。
4．下列运算符中，( )运算符不能重载。
A． && B． [] C． :: D． new
答：C。
5．下列关于运算符重载的描述中，( )是正确的。
A．运算符重载可以改变操作数的个数
B．运算符重载可以改变优先级
C．运算符重载可以改变结合性
D．运算符重载不可以改变语法结构。
答：D。
6．运算符重载函数是( )。
A．成员函数
B．友元函数
C．内联函数
D．带默认参数的函数
答：A，B。
7．关于动态联编的下列描述中，( )是错误的。
A．动态联编是以虚函数为基础的
B．动态联编是在运行时确定所调用的函数代码的
C．动态联编调用函数操作是用指向对象的指针或对象引用
D．动态联编是在编译时确定操作函数的
答：D。
8．关于虚函数的描述中，( )是正确的。
A．虚函数是一个static类型的成员函数
B．虚函数是一个非成员函数
C．基类中说明了虚函数后，派生类中将其对应的函数可不必说明为虚函数
D.派生类的虚函数与基类的虚函数具有不同的参数个数和类型
答：C
9．关于纯虚函数和抽象类的描述中，( )是错误的。
A．纯虚函数是一种特殊的虚函数，它没有具体的实现
B．抽象类是指具有纯虚函数的类
C．一个基类中说明有纯虚函数，该基类的派生类一定不再是抽象类
D．抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出
答：C。
10．下列描述中，( )是抽象类的特性。
A．可以说明虚函数
B．可以进行构造函数重载
C．可以定义友元函数
D．不能说明其对象
答：D。
二、判断下列描述的正确性，对者划√，错者划×
√1．函数的参数个数和类型都相同，只是返回值不同，这不是重载函数。
√2．重载函数可以带有默认值参数，但是要注意二义性。
√3．多数运算符可以重载，个别运算符不能重载，运算符重载是通过函数完成的。
×4．对每个可重载的运算符来讲，它既可以重载为友元函数，又可以重载为成员函数，还可以重载为非成员函数。
√5．对单目运算符重载为友元函数时，说明一个形参；重载为成员函数时，不能显式说明形参。
√6．重载运算符保持原运算符的优先级和结合性不变。
√7．虚函数是用virtual关键字说明的成员函数。
√8．构造函数说明为纯虚函数是没有意义的。
×9．抽象类是指一些没有说明对象的类。
√10．动态联编是在运行时选定调用的成员函数的。
三、分析下列程序的输出结果
1
#include＜inostram.h＞
class B
{
public:
B(int i){b=i+50; show();}
B(){}
Virtual void show( )
{
cout＜＜”B：：show()called．”＜＜b＜＜endl；
}
Protected：
int b：
}
class D：public B
{
Public：
D(int i)：B(i) {d＝i+100；show()；}
D() {}
void show()
{
cout＜＜”DC::show() called.”＜＜d＜＜endl；
}
protected:
int d：
};
void main()
{
D d1(108)；
}
运行该程序输出如下结果。
B：：show()called．158
D：：show()called．208
分析：
该程序中定义了B类和D类两个类。其中，D类是公有继承B类的派生类。在主函
数中，仅创建一个D类对象d1，于是调用D类的构造函数，先调用基类B的构造函数，给数据成员b初始化，又调用B类的show()函数，输出显示如下信息。
B::show(0 called.158
接着执行派生类D的构造函数体，给数据成员d初始化，又调用D类的show()函数，输出显示如下信息。
D::show(0 called.208
请读者思考。将B类中show()函数说明为virtual函数时，输出结果会有变化吗? 再将D类继承B类的方式改为私有，输出结果会有变化吗?为什么?
2
#include
class B
{
public：
B() {}
B(int i){b=i；}
Virtual void virfun( )
{
cout＜＜”B：：virfun()called．＼n”；
}
private:
int b;
}
class D：public B
{
public：
D() {}
D(int i，int j)：B(i){d＝j;)
Prtvate：
int d；
void virfun()
{cout＜＜”D：：virfun()called．＼n”；
}
};
void fun(B*obj)
{
obj一＞virfun()；
}
void main()
{
D * pd＝new D；
fun(pd)；
}
运行该程序输出结果如下所示。
D：：virfun()called．
分析：
该程序中，定义了派生类D公有继承基类B，基类B中说明了非静态成员函数virfun()为虚函数在派生类D中对它进行了重新定义。在一般函数fun()中，通过对象指针来调用虚函数，于是实现了动态联编，输出显示上述结果。
请读者思考下列问题。
(1)将一般函数fun()的形参改为D类的对象，并做相应修改后，输出结果会改变
吗?为什么?
(2)仅将B类中virfun()函数前边virtual关键字去掉，其余不变，输出结果会改变吗?为什么?
(3)仅将D类继承B类的方式改为私有，其余不变，编译该程序时会出现什么错误? 为什么?
3、
#include＜iostream.h＞
class A
{
public：
A(){ver＝’A’；}
void print()
{cout＜＜”The A version”＜＜ver＜＜endl；}
protected:
Char ver;
}；
class D1：public A
{
public：
D1(int number) {info=number; ver=1；}
void print()
{cout＜＜”The D1 info：”＜＜info＜＜”version”＜＜ver＜＜endl；} private：
int info;
}；
class D2：public A
{
public：
D2(int number) {info＝number; }
void print( )
{cout＜＜”The D2 info：”＜＜info＜＜”version”＜＜ver＜＜endI；} private:
int info；
}；
class D3：public D1
{ public：
D3(int number)：D1(number)
{ info=number；
ver=3;
}
void print()
{cout＜＜”The D3 info :”< int info； }； void Print_info(A *p) { p一＞print()； } void main() { A a; D1 d1(4)； D2 d2(100)； D3 d3(-25)； print_info(&a)； print_info(&d1); print_info(＆d2); print_info(& d3); } 运行该程序输出结果如下所示。 The A version A The A version l The A version A The A version 3 分析： 该程序中，定义一个基类A，又定义两个派生类D1和D2，它们公有继承基类A.又定义一个派生类D3，它公有继承Dl类。定义一个一般函数罗print_info()，它的形参是指向对象的指针。主函数中定义了4个类的4个对象，并用它们的地址值作为实参4次调用print_info()函数，它们的调用都采用静态联编，因此输出显示上述结果。 4． #include class A {public: A() {ver='A';} virtual void print(){cout<<"The A version "< protected: char ver; }; class D1: public A { public: D1(int number){info=number;ver='1';} void print() {cout<<"The D1 info: "< private: int info; }; class D2:public A { public: D2(int number) {info=number;} void print() {cout<<"The D2 info: "< private: int info; }; class D3:public D1 {public: D3(int number):D1(number) {info=number; ver='3'; } void print() {cout<<"The D3 info: "< private: int info; }; void print_info(A *p) {p->print(); } void main() { A a; D1 d1(4); D2 d2(100); D3 d3(-25); print_info(&a); print_info(&d1); print_info(&d2); print_info(&d3); } 运行该程序输出结果如下所示。 The A version A The D1 info：4 versionl The D2 info：100 version A The D3 info：-25 version 3 分析： 该程序与前面一个程序的区别仅在于类A中print()函数被说明为虚函数。由于将print()函数说明为虚函数后，使得一般函数print_info()中调用print()函数采用了动态联编，因此将获得上述的输出显示结果。 通过本程序与前一个程序的对比，进一步提高对于动态联编的认识。 5 include class Matrix public： Matrix( row=r； col=c； elem=new double[row*col] double &OperatOr( )(int x,int y) { return elem[col*(x-1)+y-1]; } ～Matrix() {delete[]elem;} private: double *elem; int row,col; }; void main() { Matrix m(5，8)； for(int i=0；i<5；i++) m(i，1)＝i+5; for(i＝0；i<5；i++) cout< cout< } 运行该程序输出结果如下所示。 5,6,7,8,9, 分析： 该程序定义的类Matrix中，使用成员函数的方法重载了运算符()。 C 、可以是void 类型 D 、可以是float 类型 A 、运算符重载可以改变运算符的操作数的个数 B 、运算符重载可以改变优先级 C 、运算符重载可以改变结合性 D 、运算符重载不可以改变语法结构 A 、动态联编是以虚函数为基础的 B 、动态联编是在运行时确定所调用的函数代码的 C 、动态联编调用函数操作是指向对象的指针或对象引用 D 、动态联编是在编译时确定操作函数的 A 、虚函数是一个静态成员函数 B 、虚函数是一个非成员函数 C 、虚函数既可以在函数说明时定义，也可以在函数实现时定义 D 、派生类的虚函数与基类中对应的虚函数具有相同的参数个数和类型 B 、重载函数和析构函数 C 、虚函数和对象 习题 10 运算符重载与多 态性 、单项选择题 A 、 ? : B 、 [ ] C 、 new D 、 && 2、 下列运算符不能用友元函数重载的是（ ）。 A 、 + B 、 = C 、 * D 、 << 3、 在一个类中可以对一个操作符进行（ ）重载。 A 、 1种 B 、 2 种以下 C 、 3 种以下 D 、 多种 4、友元运算符 obj1>obj2 被 C++ 编译器解释为（ ）。 1、下列运算符中，（ ）运算符在C++中不能重载。 A 、 operator > (obj1, obj2) B 、 > (obj1, obj2) C 、 obj2.operator > （obj1） D 、 obj1.operator > （obj2） 5、下列关于C++运算符函数的返回类型的描述中，错误的是（ ） 。 A 、可以是类类型 B 、可以是int 类型 6、下列关于运算符重载的描述中，正确的是（ ）。 9、对虚函数的调用（ ） 。 A 、 定使用动态联编 B 、必须使用动态联编 C 、 定使用静态联编 D 、不一定使用动态联编 10、编译时的多态性可以通过使用（ ）获 得。 7、下列关于动态联编的描述中，错误的是（ ）。 8、关于虚函数的描述中，正确的是（ ）。 A 、虚函数和指针 D 、虚函数和引用 实验八多态性与虚函数 一、实验目的和要求 1.了解多态的概念； 2.了解虚函数的作用及使用方法； 3.了解静态关联和动态关联的概念和用法； 4.了解纯虚函数和抽象类的概念和用法 二、实验内容和结果 1.阅读下面的程序 1.1请写出程序的执行结果，并在上机时对照理解 class Vehicle {public: void run() const { cout << "run a vehicle. "< airplane.run(); cout<<"(b) 用指向基类的指针访问成员函数: "< 第17课多态性与虚函数 一、多态性 1、多态性的概念 向不同的对象发送相同的消息，不同的对象会产生不同的行为。 在C++中，多态性的表现形式之一为：具有不同功能的函数可以用同一个函数名，这样就 可以实现用一个函数名调用不同内容的函数。 2、多态性的类别 （1）静态多态性 通过重载（函数、运算符）实现，编译时确定 （2）动态多态性 通过虚函数实现，在运行时确定调用的是哪个函数 ------------------------------------------------------------------------------- 二、静态多态性 1、实例：重载函数，输出三个数中的最大数（17_000.cpp） 2、实例：重载运算符“<<”，输出一个类对象（17_001.cpp） 3、在上例基础上，增加一个派生类：重载运算符“<<”，输出不同的类对象（17_002.cpp） 3、在上例中建立同名“display()”函数（17_002_1.cpp） 三、利用虚函数实现动态多态性 1、虚函数的作用 虚函数的作用是，允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。 2、实例：（17_004.cpp） 说明：本来，基类指针是用来指向基类对象的，如果用它来指向派生类对象，则自动进行指针类型转换，将派生类的对象的指针先转换成基类的指针，这样，基类指针指向的是派生类中的基类部分。 在基类的“display”函数前加上了“virtual”，使之成为虚函数，就可以使用基类指针调用派生类中的同名函数“display”了。 第10章多态性与虚函数 【内容提要】 多态性的概念； 函数和运算符的重载； 虚函数和抽象类。 【重点与难点】 10.1 多态性的概念 在面向对象的概念中，多态性是指不同对象接收到相同消息时，根据对象类的不同产生不同的动作。 由静态联编支持的多态性称为编译时的多态性或静态多态性，也就是说，确定同名操作的具体操作对象的过程是在编译过程中完成的。C++用函数重载和运算符重载来实现编译时的多态性。 由动态联编支持的多态性称为运行时的多态性活动太多态性，也就是说，确定同名操作的具体操作对象的过程是在运行过程中完成的。C++用继承和虚函数来实现运行时的多态性。 10.2 函数和运算符的重载 10.2.1 函数重载 面向对象程序设计中，函数的重载表现为两种情况：第一种是参数个数或类型有所差别的重载，第二种是函数的参数完全相同但属于不同的类。 10.2.2 运算符重载 C++预定义的运算符只是对基本数据类型进行操作，而对于自定义的数据类型比如类，却没有类似的操作。为了实现对自定义类型的操作，就必须自己编写程序来说明某个运算符作用在这些数据类型上时，应该完成怎样的操作，这就要引入运算符重载的概念。 运算符的重载形式有两种，一种是重载为类的成员函数，一种是重载为类的友元函数。 成员运算符函数的定义： 在类内声明的一般形式为： <返回类型> operator<运算符>(参数表)； 在类外定义的一般形式为： <返回类型> <类名∷> operator<运算符>(参数表) { 函数体 } 其中，operator是定义运算符重载函数的关键字；运算符是要重载的运算符的名称；参数表给出重载运算符所需要的参数和类型。 将重载的运算符函数定义为类的友元函数，称为友元运算符函数。友元运算符函数不 友员运算符函数的定义： 在类内声明的一般形式为： friend<返回类型> operator<运算符>(参数表)； 在类外定义的一般形式为： <返回类型> operator<运算符>(参数表) { 函数体 } 其中，friend是声明友元函数的关键字，operator是定义运算符重载函数的关键字；运 算符是要重载的运算符的名称；参数表给出重载运算符所需要的参数和类型。 几种典型运算符的重载 作业题 一、写出下列程序运行结果 1.#include }; void fun(A *a) { delete a; } int main( ) { A *a=new B(10); fun(a); } 二、程序设计题 1有一个交通工具类vehicle，将它作为基类派生小车类car、卡车类truck和轮船类boat，定义这些类并定义一个虚函数用来显示各类信息。 5.2定义一个shape抽象类，派生出Rectangle类和Circle类，计算各派生类对象的面积Area( )。 5.5某学校对教师每月工资的计算公式如下：固定工资+课时补贴。教授的固定工资为5000元,每个课时补贴50元；副教授的固定工资为3000元,每个课时补贴30元;讲师的固定工资为2000元,每个课时补贴20元。给出教师抽象类及主函数,补充编写程序求若干教师的月工资。 #include 实验5 运算符重载和多态性班级学号（最后两位）姓名成绩 一、实验目的 1．掌握用成员函数重载运算符的方法 2．掌握用友元函数重载运算符的方法 3．理解并掌握利用虚函数实现动态多态性和编写通用程序的方法 4．掌握纯虚函数和抽象类的使用 二、实验内容 1．复数类加减法乘除运算(用成员函数定义运算符重载)。 复数类的定义： class complex //复数类声明 { public: //外部接口 complex(double r=0.0,double i=0.0) //构造函数 {real=r,imag=i;} complex operator +(complex c2); //运算符"+"重载成员函数 complex operator - (complex c2); //运算符"-"重载成员函数 complex operator *(complex ); //运算符"*"重载成员函数 complex operator /(complex); //运算符"/"重载成员函数 complex operator =(complex c2); //运算符"="重载成员函数 void display(); //输出复数 private: //私有数据成员 double real; //复数实部 double imag; //复数虚部 }; 实验代码： #include 多态性和虚函数 Problem A: C++习题抽象基类Description 编写一个程序，声明抽象基类Shape，由它派生出3个派生类：Circle(圆形)、Rectangle(矩形)、Triangle(三角形)，用一个函数printArea分别输出以上三者的面积（结果保留两位小数），3个图形的数据在定义对象时给定。 Input 圆的半径 矩形的边长 三角形的底与高 Output 圆的面积 矩形的面积 三角形的面积 Sample Input 12.6 4.5 8.4 4.5 8.4 Sample Output area of circle = 498.76 area of rectangle = 37.80 area of triangle = 18.90 #include virtual double area()const=0; }; class Circle:public Shape { public: Circle(double r):radius(r) {} virtual double area() const { return 3.14159*radius*radius; }; protected: double radius; }; class Rectangle:public Shape { public: Rectangle(double w,double h):width(w),height(h) {} virtual double area() const { return width*height; } 多态性与虚函数 1．概念填空题 1.1 C++支持两种多态性,分别是编译时和运行时。 1.2在编译时就确定的函数调用称为静态联编，它通过使用函数重载，模板等实现。 1.3在运行时才确定的函数调用称为动态联编，它通过虚函数来实现。 1.4虚函数的声明方法是在函数原型前加上关键字virtual。在基类中含有虚函数，在派生类中的函数没有显式写出virtual关键字，系统依据以下规则判断派生类的这个函数是否是虚函数：该函数是否和基类的虚函数同名；是否与基类的虚函数参数个数相同、类型；是否与基类的虚函数相同返回类型。如果满足上述3个条件，派生类的函数就是虚函数。并且该函数覆盖基类的虚函数。 1.5 纯虚函数是一种特别的虚函数，它没有函数的函数体部分，也没有为函数的功能提供实现的代码，它的实现版本必须由派生类给出，因此纯虚函数不能是友元函数。拥有纯虚函数的类就是抽象类类，这种类不能实例化。如果纯虚函数没有被重载，则派生类将继承此纯虚函数，即该派生类也是抽象。 3．选择题 3.1在C++中,要实现动态联编,必须使用(D)调用虚函数。 A.类名 B.派生类指针 C.对象名 D.基类指针 3.2下列函数中,不能说明为虚函数的是(C)。 A.私有成员函数 B.公有成员函数 C.构造函数 D.析构函数 3.3在派生类中,重载一个虚函数时,要求函数名、参数的个数、参数的类型、参数的顺序和函数的返回值(A)。 A.相同 B.不同 C.相容 D.部分相同 3.4当一个类的某个函数被说明为virtual时，该函数在该类的所有派生类中（A）。 A．都是虚函数 B．只有被重新说明时才是虚函数 C．只有被重新说明为virtual时才是虚函数 D．都不是虚函数 3.5（C）是一个在基类中说明的虚函数，它在该基类中没有定义，但要求任何派生类都必须定义自己的版本。 A．虚析构函数B．虚构造函数 C．纯虚函数D．静态成员函数 3.6 以下基类中的成员函数，哪个表示纯虚函数（C）。 A．virtual void vf(int)；B．void vf(int)=0； C．virtual void vf( )=0；D．virtual void vf(int){ } 3.7下列描述中，（D）是抽象类的特性。 A．可以说明虚函数 B．可以进行构造函数重载 C．可以定义友元函数 D．不能定义其对象 3.8类B是类A的公有派生类，类A和类B中都定义了虚函数func( )，p是一个指向类A对象的指针，则p->A::func( )将（A）。 [实验目的] 1、了解多态性的概念； 2、了解虚函数的用途及使用方法； 3、了解纯虚函数和抽象类的概念和用法。 [实验要求] 给出以下各实验内容的源程序代码，并把编译、运行过程中出现的问题以及解决方法填入实验报告中，按时上交。 [实验学时] 2学时。 [实验内容] 1、写一个程序，定义抽象基类Shape，由它派生出3个派生类：Circle(圆形)、Square(正方形)、Rectangle(矩形)。利用指针、虚函数printArea()分别输出以上三者的面积，3个图形的数据在定义对象时给定。 [源程序] #include class Rectangle:public Shape { public: Rectangle(double a,double b):l(a),w(b){} virtual float area()const{return l*w;} virtual void display()const { cout<<"矩形面积"< . 西华大学实验报告（计算机类） 开课学院及实验室：机械工程与自动化 实验时间 ： 年 月 日 一、实验目的 1. 理解虚函数的特性； 2. 理解纯虚函数和抽象类的特性； 3. 掌握用虚函数实现运行时的多态性和编写通用程序的方法； 4. 掌握用成员函数和友元函数重修运算符的方法。 二、内容与设计思想 上机实践内容： 1． 定义一个抽象类CShape ，包含纯虚函数Area （）（原来计算面积）和SetData （）（原 来重设形状大小）。然后派生出三角形CTriangle 类、矩形CRect 类、圆CCircle 类，分别求其面积。最后定义一个CArea 类，计算这几个形状的面积之和，个形状的数据通过CArea 类构造函数或成员函数来设置。编程一个完整的程序。 2． 定义一个复数类CComplex ，通过重载运算符“*”和“/”，直接实现两个复数之间的 乘除运算。编写一个完整的程序（包括测试运算符的程序部分）。运算符“*”用成员函数实现重载，而运算符“/”用友元函数实现重载。 提示：两复数相乘的计算公式为：(a+bi)*(c+di)=(ac-bd)+ad+bc)i; 两复数相除的计算公式为：(a+bi)/(c+di)=(ac+bd)/(c*c+d*d)+(bc-ad)/(c*c+d*d)i 三、使用环境 操作系统：Windowns XP Ｃ++环境：Visual C++ 6.0 四、核心代码及调试过程 #include 贵州大学实验报告 学院：电子信息学院专业：通信工程班级： 姓名学号实验组5实验时间指导教师成绩 实验项目名称多态性 实 验通过让学生进行实验，使其对于动态多态性有一个较为深入的了解和熟悉。最终可以目熟练使用。 的 实 1．编写 4 个重载函数 Double（ x），返回值为输入参数的两倍；参数类型分别为int 、验long 、float 、 double ，返回值类型与参数类型一样。 2．请编写一个抽象类Shape，在此基础上派生出类Rectangle和Circle，二者都有 要 计算对象面积的函数GetArea （）和计算周长函数GetPerim （）。 求3．对类 Point 重载 ++（自增）、 -- （自减）运算符。 实 验Visual C++的编译环境下，独立完成实验要求的内容，独立完成编写、编译以及运行 原的过程 理 实 验 安装了 Visual C++ 的 PC机器 仪 器 实 验 按照实验要求的内容逐一完成实验的要求。顺序是编写、编译、运行。 步 骤 实 1. 编写 4 个重载函数 Double（x），返回值为输入参数的两倍；参数类型分别为int、 验 long 、 float 、 double ，返回值类型与参数类型一样。 2. 请编写一个抽象类Shape，在此基础上派生出类Rectangle 和 Circle，二者都有计 内算对象面积的函数GetArea （）和计算周长函数GetPerim （）。容 3. 对类 Point 重载 ++（自增）、 -- （自减）运算符。 1、代码如下： #include 实验六多态性和虚函数 一、实验目的 1、了解多态性的概念。 2、了解虚函数的作用及其使用方法。 3、了解静态关联和动态关联的概念和用法。 4、了解纯虚函数和抽象类的概念和用法。 二、实验要求 1、分析程序运行结果，掌握虚函数的使用。 程序一： #include { Base bc,*p; SubClass sc; p=&bc; p->fn(); p=≻ p->fn(); } 2、实现一个类A，在A中有两个私有的整型变量a和b，定义构造函数对a和b进行初始化，并实现成员函数geta（）取得a的值和getb（）取b的值。实现类B从A继承，覆盖geta（），使其返回a的2倍。主函数中声明类B对象，调用类B中的geta（）并将结果输出。 3、声明抽象基类Shape，由它派生出3个派生类：Cirle（圆形）、Rectangle（矩形）、Triangle （三角形），用一个函数printArea分别输出以上三者的面积，3个图形的数据在定义对象是给定。 实验三虚函数与多态、纯虚函数 一.实验目的 1. 在掌握继承与派生关系的基础上，进一步理解虚函数与多态性的关系，实现运行时的多态。 2. 学会定义和使用纯虚函数 二、实验内容 1．范例：了解"单接口，多方法"的概念。现有称为figure的基类，存放了各二维对象（三角形、矩形和圆形三个类）的各维数据，set_dim()设置数据，是标准成员函数。 show_area()为虚函数，因为计算各对象的面积的方法是不同的。 【程序】 #include < iostream > using namespace std; class figure{ protected: double x,y; public: void set_dim(double i,double j=0) { x=i; y=j; } virtual void show_area() { cout<<"No area computation defined for this class.\n"; } }; class triangle:public figure{ public: void show_area() { cout<<"Triangle with height "<< x<<" and base "<< y<<" has an area of "<< x*0.5*y<< endl; } }; class square:public figure{ public: void show_area() { cout<<"Square with dimensions "<< x<<" and "<< y<<" has an area of "<< x*y<< endl; } }; class circle:public figure{ public: void show_area() { cout<<"Circle with radius "<< x<<" has an area of "<<3.14159*x*x<< endl; } }; int main(){ figure *p; triangle t; square s; 1．概念填空题 1.1 C++支持两种多态性,分别是静态和动态。 1.2在编译时就确定的函数调用称为静态联编，它通过使用重载函数实现。 1.3在运行时才确定的函数调用称为动态联编，它通过虚函数来实现。1.4虚函数的声明方法是在函数原型前加上关键字 virtual 。在基类中含有虚函数，在派生类中的函数没有显式写出virtual关键字，系统依据以下规则判断派生类的这个函数是否是虚函数：该函数是否和基类的虚函数参数个数相同 /同名；是否与基类的虚函数相应类型相同；是否与基类的虚函数返回值类型相同。如果满足上述3个条件，派生类的函数就是虚函数。并且该函数覆盖基类的虚函数。 1.5当通过指针或应用使用虚函数时，C++会在与对象关联的派生类中正确的选择重定义的函数。实现了运行时多态。而通过对象使用虚函数时，不能实现运行时多态。 1.6 纯虚函数是一种特别的虚函数，它没有函数的函数体部分，也没有为函数的功能提供实现的代码，它的实现版本必须由派生类给出，因此纯虚函数不能是。拥有纯虚函数的类就是抽象类，这种类不能建立对象。如果纯虚函数没有被重载，则派生类将继承此纯虚函数，即该派生类也是纯虚函数。 1.7 类的构造函数不可以(可以/不可以)是虚函数，类的析构函数可以(可以/不可以)是虚函数。当类中存在动态内存分配时经常将类的析构函数声明成虚函数。 2．简答题 2.1在C++中，能否声明虚构造函数？为什么？能否声明虚析构函数？为什么？ 不可以声明纯构造函数，可以声明纯析构函数，因为C++中构造函数不能够被继承，而唇函数具有强继承性 2.2 什么是抽象类？抽象类有何作用？可以声明抽象类的对象吗？为什么？ 一个类中至少有一个纯纯虚函数 抽象类中的纯虚函数可以在抽象类中定义，也可以是从它的抽象类中继承下来重订于定义 可以声明抽象类的指针和引用 2.3多态性和虚函数有何作用？ 2.4是否使用了虚函数就能实现运行时的多态性?怎样才能实现运行时的多态性? 2.5为什么析构函数总是要求说明为虚函数? 3．选择题 3.1在C++中,要实现动态联编,必须使用( D )调用虚函数。 A.类名 B.派生类指针 C.对象名 D.基类指针 3.2下列函数中,不能说明为虚函数的是( )。 A.私有成员函数 B.公有成员函数 C.构造函数 D.析构函数 3.3在派生类中,重载一个虚函数时,要求函数名、参数的个数、参数的类型、参数的顺序和函数的返回值( )。 A.相同 B.不同 C.相容 D.部分相同 3.4当一个类的某个函数被说明为virtual时，该函数在该类的所有派生类中（）。 A．都是虚函数 多态性与虚函数练习 1．设计一个评选优秀教师和学生的程序，其类结构如图1所示。当输入一系列教师或学生的记录后，将优秀学生及教师的姓名列出。 图1 类结构 假设运行结果如下所示：#include 实验三继承与多态性 一、实验目的与要求 1、掌握继承、基类和派生类的概念。 2、掌握初始化基类成员的方法。 3、掌握派生类对基类的继承。 4、学习虚函数和纯虚函数的定义与使用方式。 5、理解抽象类的概念，学习如何用指针指向其他的派生类，实现多态性。 6、掌握抽象类的定义与使用方式，并注意指针的用法。 7、学习如何使用虚函数、纯虚函数、抽象类和实现类的多态性。 二、实验设备与平台 实验设备要求每个学生一台电脑，其中运行环境为VC++ 6.0系统或新版。 三、实验内容与步骤 实验：编写一个人员信息管理系统。这个系统的功能是：交互式地实现校园人员信息的录入与显示。 分析： 学校里，主要有四类人员：大学本科学生、教师、研究生和助教。 大学本科生每周有固定的学时数。教师除了固定的学时数外，还有每周的教学时数。研究生除了固定的学时数外，每周还可以自由做一定的研究。助教除了上课外，还要做研究和一定的教学工作。 人员的基本信息包括姓名、编号、性别、身份证号、总学时数、以及每周固定学时数。各个人员之间的关系：people类派生出student类和teacher类，student类派生出graduate 类，graduate类和teacher类派生出TA类。 以下给出部分程序： #include public: //添加程序 private: }; class teacher: virtual public people { public: //添加程序 private: }; class graduate: virtual public student { public: //添加程序 private: }; class TA: public graduate, public teacher { public: //添加程序 private: }; void main() { //添加程序 } 淮海工学院计算机科学系实验报告书 课程名：《 C++程序设计(二)》 题目：多态性和虚函数 班级： 学号： 姓名： 1、实验内容或题目 （1）声明二维坐标类作为基类派生圆的类，把派生类圆作为基类，派生圆柱体类。其中，基类二维坐标类有成员数据：x、y坐标值；有成员函数：构造函数实现对基类成员数据的初始化、输出的成员函数，要求输出坐标位置。派生类圆类有新增成员数据：半径（R）；有成员函数：构造函数实现对成员数据的初始化、计算圆面积的成员函数、输出半径的成员函数。派生圆柱体类新增数据有高（H）；新增成员函数有：构造函数、计算圆柱体体积的函数和输出所有成员的函数。请完成程序代码的编写、调试。 （2）教材393页7－8题。 （3）教材416页1、4、5题。 2、实验目的与要求 （1）理解继承与派生的概念 （2）掌握通过继承派生出一个新的类的方法 （3）了解多态性的概念 （4）了解虚函数的作用与使用方法 3、实验步骤与源程序 ⑴实验步骤 先定义一个基类point，及其成员函数，然后以public的继承方式定义子类circle，再定义一个派生类cylinder，最后在main主函数中定义类对象，调用函数实现其功能。 先定义一个基类A及其重载的构造函数,然后以Public派生出子类B，再定义其构造函数,最后在main主函数中定义类对象，调用成员函数实现其功能。 ⑵源代码 1.#include 多态与虚函数练习 选择题 单选题 1.要实现动态多态性，可以通过（）调用虚函数。 A. 基类指针 B. 成员名限定 C. 对象名 D. 派生类名 2.以下（）成员函数表示纯虚函数。 A. virtual int vf(int); B. void vf(int)=0; C. virtual void vf()=0; D. virtual void vf(int) { }; 3.关于纯虚函数和抽象类的描述中，错误的是（）。 A. 纯虚函数是一种特殊的虚函数，它没有具体的实现 B. 抽象类是指具有纯虚函数的类 C. 一个基类中说明有纯虚函数，该基类派生类一定不再是抽象类 D. 抽象类只能作为基类来使用，其纯虚函数的实现由派生类给出 4.下面4个选项中，（）是用来声明虚函数的。 A. virtual B. public C. using D. false 5.下列关于动态联编的描述中，错误的是（）。 A. 动态联编是以虚函数为基础 B. 动态联编是运行时确定所调用的函数代码的 C. 动态联编调用函数操作是指向对象的指针或对象引用 D. 动态联编是在编译时确定操作函数的 6.关于虚函数的描述中，（）是正确的。 A. 虚函数是一个静态成员函数 B. 虚函数是一个非成员函数 C. 虚函数既可以在函数说明时定义，也可以在函数实现时定义 D. 派生类的虚函数与基类中对应的虚函数具有相同的参数个数和类型 7.下面关于友元的描述中，错误的是（）。 A. 友元函数可以访问该类的私有数据成员 B. 一个类的友元类中的成员函数都是这个类的友元函数 C. 友元可以提高程序的运行效率 D. 类与类之间的友元关系可以继承 8.下面描述中，正确的是（）。 A. virtual可以用来声明虚函数 B. 含有纯虚函数的类是不可以用来创建对象的，因为它是虚基类 实验六虚函数与多态性 一、实验目的和要求 1.理解静态多态性和动态多态性。 2.掌握运算符重载的基本方法。 3.掌握虚函数的定义与使用方法。 二、实验内容 1.定义一个类Animal，该类中可以存放动物的名字，并有一个Identify函数用于显示动物的种类。定义两个类Cat和Dog，都继承自Animal，并重载Identify函数，不但要显示动物的种类，还要显示动物的名字。定义一个Tiger类，继承自Cat，重载Identify函数，显示动物的种类和名字。 #include Dog(string Name,string Kind):Animal(Name,Kind) {} void show() { cout<<"狗的种类和名字是:"<习题10-运算符重载与多态性
实验8 多态性与虚函数
多态性与虚函数
11多态性与虚函数
c++多态性与虚函数习题
c++运算符重载和多态性实验报告
多态性和虚函数
c++多态性与虚函数习题答案
实验6多态性与虚函数
西华大学C++实验报告5 多态和虚函数、运算符重载
C++实验多态性实验报告
实验六 多态性和虚函数
实验三虚函数与多态纯虚函数(完全版)
c多态性与虚函数习题
多态性与虚函数练习
实验五 虚函数与多态性
多态性和虚函数 实验报告
多态与虚函数 练习题
计科实验六多态的应用参考答案
相关主题
文本预览