实验目的和要求
 
了解静态联编的动态联编的概念。掌握动态联编的条件。
 
 
实验内容
 
1.分析并调试下列程序。
 
//sy6_1.cpp
#include<iostream>
using namespace std;
class Base
{
    public:
        virtual void f(float x){cout<<"Base::f(float)"<<x<<endl;}
        void g(float x){cout<<"Base::g(float)"<<x<<endl;}
        void h(float x){cout<<"Base::h(float)"<<x<<endl;}
};
class Derived:public Base
{
    public:
        virtual void f(float x){cout<<"Derived::f(float}"<<x<<endl;}
        void g(int x){cout<<"Derived::g(int)"<<x<<endl;}
        void h(float x){cout<<"Derived::h(float)"<<x<<endl;}
};
int main()
{
    Derived d;
    Base *pb=&d;
    Derived *pd=&d;
    pb->f(3.14f);
    pd->f(3.14f);
    pb->g(3.14f);
    pb->h(3.14f);
    pd->h(3.14f);
    return 0;
}
 
（1）找出以上程序中使用了重载和覆盖函数。
 
答：Base类中函数void g（）; 和void h（）；与Derived类中的函数void g（）; 和void h（）；函数名相同，参数类型不同，构成了函数重载。
 
（2）写出程序的输出结果，并解释输出结果。 
  
 输出结果解释： 
 pb和pd指向同一地址，它们运行结果应该是相同的，但实际运行出来的结果却不相同，原因是决定pb和pd调用函数运行结果的不是他们指向的地址，而是他们的指针类型。“只有在通过基类指针或引用间接指向派生类子类型时多态性才会起作用”。在程序中pb是基类指针，pd是派生类指针，pd的所有函数调用都只是调用自己的函数，和多态性无关，所以pd的所有函数调用的结果都输出Derived::是完全正常的；pb的函数调用如果有virtual则根据多态性调用派生类的，如果没有virtual则是正常的静态函数调用，还是调用基类的，所以有virtual的f函数调用输出Derived::，其它两个没有virtual则还是输出Base::。 
 2. 分析并调试下列程序
 
//sy6_3.cpp
#include<iostream>
using namespace std;
class Base
{
    public:
        void f(int x){cout<<"Base::f(int)"<<x<<endl;}
        void f(float x){cout<<"Base::f(float)"<<x<<endl;}
        virtual void g(void){cout<<"Base::g(void)"<<endl;}
};
class Derived:public Base
{
    public:
        virtual void g(void){cout<<"Derived::g(void}"<<endl;}
};
int main()
{
    Derived d;
    Base *pb=&d;
    pb->f(42);
    pb->f(3.14f);
    pb->g();
    return 0;
}
 
（1）找出以上程序中使用了重载和覆盖函数。 
 答：Base类中函数void f（）; 在同一作用域中，函数名相同，参数类型不同，构成了函数重载。
 
（2）写出程序的输出结果，并解释输出结果。 
 
 
3. 分析并调试下列程序 
 写出程序的输出结果，并解释输出结果。
 
//sy6_3.cpp
#include<iostream>
using namespace std;
class Point
{
    public:
        Point(double i,double j){x=i;y=j;}
        double Area(){return 0.0;}
    private:
        double x,y;
};
class Rectangle:public Point
{
    public:
        Rectangle(double i,double j,double k,double l):Point(i,j){w=k;h=l;}
        double Area(){return w*h;}
    private:
        double w,h;
};  
int main()
{
    Point p(3.5,7);
    double A=p.Area();
    cout<<"Area= "<<A<<endl;
    Rectangle r(1.2,3,5,7.8);
    A=r.Area();
    cout<<"Area= "<<A<<endl;
    return 0;
}
 
 
4. 分析并调试下列程序
 
//sy6_4.cpp
#include<iostream>
using namespace std;
const double PI=3.1415;
class Shap
{
    public:
        virtual double Area()=0;
};
class Triangle:public Shap
{
    public:
        Triangle(double h,double w){H=h;W=w;}
        double Area(){return 0.5*H*W;}
    private:
        double H,W;
};
class Rectangle:public Shap
{
    public:
        Rectangle(double h,double w){H=h;W=w;}
        double Area(){return H*W;}
    private:
        double H,W;
};
class Circle:public Shap
{
    public:
        Circle(double r){R=r;}
        double Area(){return PI*R*R;}
    private:
        double R;
};  
class Square:public Shap
{
    public:
        Square(double s){S=s;}
        double Area(){return S*S;}
    private:
        double S;
};
double Total(Shap *s[],int n)
{
    double sum=0;
    for(int i=0;i<n;i++)
        sum+=s[i]->Area();
    return sum;
}
int main()
{
   Shap *s[5];
   s[0]=new Square(8.0);
   s[1]=new Rectangle(3.0,8.0);
   s[2]=new Square(12.0);
   s[3]=new Circle(8.0);
   s[4]=new Triangle(5.0,4.0);
   double sum=Total(s,5);
   cout<<"SUM = "<<sum<<endl;
    return 0;
}
 
程序的输出结果如下： 
  
 （1）指出抽象类。 
 （2）指出纯虚函数，并说明它的作用。 
 （3）每个类的作用是什么？整个程序的作用是什么？
 
5. 某学校对教师每个月工资的计算规定如下：固定工资+课时补贴；教授的固定工资为5000元，每个课时补贴50；副教授的固定工资为3000，每个课时补贴30元；讲师的固定工资为2000元，每个课时补贴20元。定义教师抽象类，派生不同职称的教师类，编写程序求若干个教师的月工资。（sy6_5.cpp)
 
//sy6_5.cpp
#include <iostream>
using namespace std;
class teacher
{
public:
    virtual int salary()=0;
    virtual void print(int)=0;
};

class professor:public teacher
{
public:
    professor()
    {
        cout<<"教授：";
        cin>>name;
        cout<<"课时：";
        cin>>lessons;
    };
    int salary()
    {
        return (5000+lessons*50);
    };
    void print(int money)
    {
        cout<<"职称：教授 姓名："<<name<<" 薪水："<<money<<endl<<endl;
    };
private:
    char name[128];
    int lessons;
};

class associateprofessor:public teacher
{
private:
    char name[128];
    int lessons;
public:
    associateprofessor()
    {
        cout<<"副教授：";
        cin>>name;
        cout<<"课时：";
        cin>>lessons;
    };
    int salary()
    {
        return (3000+lessons*30);
    };
    void print(int money)
    {
        cout<<"职称：副教授 姓名："<<name<<" 薪水："<<money<<endl<<endl;
    };
};

class Lecturer:public teacher
{
private:
    char name[128];
    int lessons;
public:
    Lecturer()
    {
        cout<<"讲师：";
        cin>>name;
        cout<<"课时：";
        cin>>lessons;
    };
    int salary()
    {
        return (2000+lessons*20);
    };
    void print(int money)
    {
        cout<<"职称：讲师 姓名："<<name<<"薪水："<<money<<endl<<endl;
    };
};

int main()
{
    teacher *t = NULL;
    int money=0;
     t = new professor();
    money = t->salary();
    t->print(money);
    delete t;

    t = new associateprofessor();
    money = t->salary();
    t->print(money);
    delete t;

    t = new Lecturer();
    money = t->salary();
    t->print(money);
    delete t;
    t = NULL;
    return 0;
}
 
输出结果： 
 
 
 
分析与讨论
 
1.结合实验内容中第1题和第2题，说明重载与覆盖的区别。
 
 
 
重载与覆盖的区别： 
 1、方法的覆盖是子类和父类之间的关系，是垂直关系；方法的重载是同一个类中方法之间的关系，是水平关系 
 2、覆盖只能由一个方法，或只能由一对方法产生关系；方法的重载是多个方法之间的关系。 
 3、覆盖要求参数列表相同；重载要求参数列表不同。 
 4、覆盖关系中，调用那个方法体，是根据对象的类型（对象对应存储空间类型）来决定；重载关系，是根据调用时的实参表与形参表来选择方法体的。
 
 
2.总结静态联编和动态联编的区别和动态联编的条件。 
 答：静态联编是指联编工作在编译阶段完成的，这种联编过程是在程序运行之前完成的，又称为早期联编。要实现静态联编，在编译阶段就必须确定程序中的操作调用（如函数调用）与执行该操作代码间的关系，确定这种关系称为束定，在编译时的束定称为静态束定。静态联编对函数的选择是基于指向对象的指针或者引用的类型。其优点是效率高，但灵活性差。
 
动态联编是指联编在程序运行时动态地进行，根据当时的情况来确定调用哪个同名函数，实际上是在运行时虚函数的实现。这种联编又称为晚期联编，或动态束定。动态联编对成员函数的选择是基于对象的类型，针对不同的对象类型将做出不同的编译结果。C++中一般情况下的联编是静态联编，但是当涉及到多态性和虚函数时应该使用动态联编。动态联编的优点是灵活性强，但效率低。
 
动态联编的条件： 
 ①必须把动态联编的行为定义为类的虚函数。 
 ②类之间应满足子类型关系，通常表现为一个类从另一个类公有派生而来。 
 ③必须先使用基类指针指向子类型的对象，然后直接或者间接使用基类指针调用虚函数。

所使用的开发工具及环境： PC机一套
 
实验目的：
 (1)了解多态性的概念。
 (2)了解虚函数的作用及使用方法。
 (3)了解静态关联和动态关联的概念和川法。
 (4)了解纯虚函数和抽象类的概念和用法。
 
实验内容：
 1、分析程序运行结果，掌握虚函数的使用。
 程序一：
 
#include <iostream>
using namespace std;
class ONE
{  public:
      virtual void f(){cout<<"ONE"<<endl;}
};
class TWO:public ONE
{  public:
      TWO(){cout<<"TWO"<<endl;}
};
class THREE:public TWO
{  public:
      virtual void f(){TWO::f(); cout<<"THREE";}
};
void main()
{  ONE aa, *p;
   TWO bb;  //TWO
   THREE cc;  //TWO
   p = &cc;
   p->f();//ONE THREE
   cout<<endl;
}
 
程序二：
 
#include <iostream>
using namespace std;
class Base
{ public:
   virtual void fn() { cout <<"In Base Class\n";}
};
class SubClass :public Base
{  public:
    virtual void fn(){  cout <<"In Sub Class\n";  }//覆盖
};
void main()
{   Base bc,*p;
    SubClass sc;
    p=&bc;   p->fn();//In Base Class
    p=&sc;   p->fn();//In Sub Class
}
 
2、实现一个类A，在A中有两个私有的整型变量a和b，定义构造函数对a和b进行初始化，并实现成员函数geta（）取得a的值和getb（）取b的值。实现类B从A继承，覆盖geta（），使其返回a的2倍。主函数中声明类B对象，调用类B中的geta（）并将结果输出。
 
#include<iostream>
using namespace std;
class A
{
	public:
		A(int a,int b):a(a),b(b){}
		virtual int geta(){return a;}
		friend class B;
private:
	int a;
	int b;
};
class B:public A
{
public:
	B(int a,int b):A(a,b){}
	int geta(){return 2*a;}
};
int main()
{
	A *p=new B(2,3);
	cout<<p->geta()<<endl;
system("pause");
return 0;
}

 
3、设计一个计算图形面积的类库。它的顶层是一个抽象类，并且提供相应的接口函数。抽象基类Shape，派生出Point类、矩形Rectangle、正方形Square，Point类派生出圆形Circle。 要求：
 （1）每个类有构造函数、析构函数，并有相应的输出语句，如：“正在构造圆形”
 （2）能显示每个类的信息，如：输出“我是圆形”
 （3）能计算面积、周长
 （4）定义一个基类Shape类型的指针，实现动态多态
 （5）动态创建一个圆形对象，赋值给基类Shape类型的指针变量，程序最后delete该指针，保证析构函数的正确调用（提示：虚析构函数）
 （6）在主函数测试。
 
#include<iostream>
using namespace std;
const double PI=3.1415926;
class Shape
{
public:
	Shape(){cout<<"Constructing Shape..."<<endl;}
	virtual ~Shape(){cout<<"Destructing Shape..."<<endl;}
	virtual void Name(){cout<<"Share"<<endl;}
	virtual double Area()=0;
	virtual double C()=0;
};
class Point: public Shape
{
public:
	Point(){cout<<"Constructing Point..."<<endl;}
	~Point(){cout<<"Destructing Point..."<<endl;}
	virtual void Name(){cout<<"Point"<<endl;}
	double Area(){return 0;}
	double C(){return 0;}
};
class Rectangle:public Shape
{
public:
	Rectangle(int l,int w):length(l),width(w){cout<<"Constructing Rectangle..."<<endl;}
	~Rectangle(){cout<<"Destructing Rectangle..."<<endl;}
	double Area(){return length*width;}
	double C(){return (length+width)*2;}
	void Name(){cout<<"Rectangle"<<endl;}
private:
	double length;
	double width;
};
class Squre:public Shape
{
public:Squre(int l):L(l){cout<<"Constructing Squre..."<<endl;}
	   ~Squre(){cout<<"Destructing Squre..."<<endl;}
	   void Name(){cout<<"Squre"<<endl;}
	   double Area(){return L*L;}
	   double C(){return 4*L;}
private:
	double L;
};
class Circle: public virtual Point
{
public:
	Circle(double r):radious(r){cout<<"Constructing Circle..."<<endl;}
	~Circle(){cout<<"Destructing Circle..."<<endl;}
	void Name(){cout<<"Circle"<<endl;}
	double Area(){return PI*radious*radious;}
	double C(){return 2*PI*radious;}
private:
	double radious;
};
int main()
{
	Shape *p;
	p=new Point;
	p->Name();
	cout<<"C:"<<p->C()<<endl;
	cout<<"Area:"<<p->Area()<<endl;
	delete p;
	cout<<endl;
	 p=new Rectangle(2,3);
	p->Name();
	cout<<"C:"<<p->C()<<endl;
	cout<<"Area:"<<p->Area()<<endl;
	delete p;
	cout<<endl;
	p=new Squre(4);
	p->Name();
	cout<<"C:"<<p->C()<<endl;
	cout<<"Area:"<<p->Area()<<endl;
	delete p;
	cout<<endl;
	p=new Circle(5);
	p->Name();
	cout<<"C:"<<p->C()<<endl;
	cout<<"Area:"<<p->Area()<<endl;
	delete p;
	system("pause");
}

 
4、设计一个基类Base，其作用是计算一个图形的面积，它只有一个公有的函数成员虚函数area。再从Base 类公有派生一个三角形类Triangle 和一个圆类Circle，在类Triangle 和类Circle 中分别定义自己的area 函数，用于计算各自的面积。在主函数中设计一个Base 类的对象指针，分别指向类Triangle 和类Circle 的对象，调用各自的area 函数显示相应 对象的面积。
 分析：用虚函数实现多态。
 
#include<iostream>
#include<iostream>
using namespace std;
const double PI=3.1415926;
class Base
{
public:
	Base(){cout<<"Constructing Base..."<<endl;}
	virtual ~Base(){cout<<"Destructed Base."<<endl;}
	virtual double Area()=0;
};
class Triangle:public Base
{
public:
	Triangle(double a,double b,double c):a(a),b(b),c(c){cout<<"Constructing Triangle..."<<endl;}
	~Triangle(){cout<<"Destructed Triangle."<<endl;}
	double Area(){return sqrt(0.5*(a+b+c)*(0.5*(a+b+c)-a)*(0.5*(a+b+c)-b)*(0.5*(a+b+c)-c));}
private:
	double a,b,c;
};
class Circle:public Base
{
public:
	Circle(double r):radious(r){cout<<"Constructing Circle..."<<endl;}
	~Circle(){cout<<"Destructed Circle."<<endl;}
	double Area(){return PI*radious*radious;}
private:
	double radious;
};
int main()
{
	Base *p;
	p=new Triangle(3,4,5);
	cout<<"Area:"<<p->Area()<<endl;
	delete p;
	cout<<endl;
	p=new Circle(4);
	cout<<"Area:"<<p->Area()<<endl;
	delete p;
	cout<<endl;
	system("pause");
	return 0;
}

 
5．将上题中的Base 类改为抽象类，应用抽象类，求矩形、圆形的周长和面积。
 分析：将Base 类的其成员函数area 和perimeter 声明为纯虚函数，Base 就成为一个抽 象类。然后再从Base 派生矩形类和圆形类，分别实现Base 中纯虚函数的功能.
 
#include<iostream>
using namespace std;
const double PI=3.1415926;
class Base
{
public:
	Base(){cout<<"Constructing Base..."<<endl;}
	virtual ~Base(){cout<<"Destructed Base."<<endl;}
	virtual double Area()=0;
	virtual double Perimeter()=0;  //周长
};
class Triangle:public Base
{
public:
	Triangle(double a,double b,double c):a(a),b(b),c(c){cout<<"Constructing Triangle..."<<endl;}
	~Triangle(){cout<<"Destructed Triangle."<<endl;}
	double Area(){return sqrt(0.5*(a+b+c)*(0.5*(a+b+c)-a)*(0.5*(a+b+c)-b)*(0.5*(a+b+c)-c));}
	double Perimeter(){return a+b+c;}
private:
	double a,b,c;
};
class Circle:public Base
{
public:
	Circle(double r):radious(r){cout<<"Constructing Circle..."<<endl;}
	~Circle(){cout<<"Destructed Circle."<<endl;}
	double Area(){return PI*radious*radious;}
	double Perimeter(){return 2*PI*radious;}
private:
	double radious;
};
int main()
{
	Base *p;
	p=new Triangle(3,4,5);
	cout<<"Area:"<<p->Area()<<endl;
	cout<<"Perimeter:"<<p->Perimeter()<<endl;
	delete p;
	cout<<endl;
	p=new Circle(4);
	cout<<"Area:"<<p->Area()<<endl;
	cout<<"Perimeter:"<<p->Perimeter()<<endl;
	delete p;
	cout<<endl;
	system("pause");
	return 0;
}

问题背景：
 将任意一个平面图形（如长方形、三角形、圆形等）沿其法线方向平移一定长度，它所扫过的空间区域为一个柱体。例如，长方形、圆形和三角形所形成的柱体分别如图(a)(b)©所示。
 实验题：
 柱体的体积 和表面积 计算公式分别为：
 
式中， 和 分别为柱体的底面积和底面周长。
 请用C++语言编写面向对象程序，实现柱体体积和表面积的计算（圆柱和四棱柱为必做内容，三棱柱为选做内容）。例如底面半径为2、高为4的圆柱，体积为50.27，表面积为75.40；以长为3、宽为2的长方形为底面，高为5的四棱柱，体积为30，表面积为62。
 提示：
 注意：以下定义的类中，若未给出构造函数、析构函数及输出函数，请根据需要添加。
 1、 定义一个描述平面图形的抽象类Plane，其成员函数如下表：
 
函数名 访问权限 形参 返回值 功能 虚函数？
 area public void float 求面积 纯虚函数
 girth public void float 求周长 纯虚函数
 
2、定义一个描述柱体的类Body：
 
(1) 类Body的成员变量如下表：
 
变量名 访问权限 类型 含义
 pbasic private Plane * 指向柱体的底面图形
 high private float 给出柱体的高
 
(2) 类Body的成员函数如下表：
 
函数名 访问权限 形参 返回值 功能 虚函数？
 volume public void float 求体积 否
 surfaceArea public void float 求表面积 否
 3、从抽象类Plane派生出具体类（如长方形类Rectangle、圆形类Circle和三角形类triangle），根据实际情况，覆盖基类Plane的纯虚函数area和girth，如下表。
 
函数名 访问权限 形参 返回值 功能 虚函数？
 area public void float 求面积 自动为虚函数
 girth public void float 求周长 自动为虚函数
 
(1) 长方形类Rectangle的成员变量为
 
变量名 访问权限 类型 含义
 a private float 给出长方形的长
 b private float 给出长方形的宽
 
(2) 圆形类Circle的成员变量为
 
变量名 访问权限 类型 含义
 a private float 给圆形的半径
 
(3) 三角形类Triangle的成员变量为
 
变量名 访问权限 类型 含义
 A private Point 给出三角形的顶点A
 B private Point 给出三角形的顶点B
 C private Point 给出三角形的顶点C
 
其中，Point为描述平面点的类，其成员变量为：
 
变量名 访问权限 类型 含义
 x public float 给出顶点的x坐标
 y public float 给出顶点的y坐标
 
附代码
 ！！！编译环境 DevC++ 5.11 TDM-GCC 4.9.2 64-Bit Release
 头文件 iquery.h
 
#ifndef  _IQUERY_H
#define _IQUERY_H 1
	using namespace std;
	class Plane
	{
		public:
			virtual float area() const =0;
			virtual float girth() const =0;
	}
	class Body
	{
		public:
			float volume();
			float surfaceArea();
			void setpb(Plane *p);
			void sethigh();
		private:
			Plane *pbasic;
			float high;
	};
	
	class Point
	{
		public:
			void setpoint();
			float x;
			float y;
	};
	class Rectangle: public Plane
	{
		public:
			void setrec();
			virtual float area()const;
			virtual float girth()const;
		private:
			float a;
			float b;
	};
	class Circle: public Plane
	{
		public:
			void setcir();
			virtual float area()const;
			virtual float girth()const;
		private:
			float a;
	};
	class Triangle: public Plane
	{
		public:
			void settri();
			virtual float area()const;
			virtual float girth()const;
		private:
			Point A;
			Point B;
			Point C;
	};
#endif
 
头文件实现文件 iquery,cpp
 
#include <iostream>
#include "string"
#include "iquery.h"
#include "iomanip"
#include "cmath" 
using namespace std; 
float Body::volume(){
	return pbasic->area()*high;
}
float Body::surfaceArea(){
	return 2*pbasic->area()+pbasic->girth()*high;
}
void Body::setpb(Plane *p){
	pbasic=p;
}
void Body::sethigh(){
	cin >>high;
}
void Rectangle :: setrec(){
	cout << "输入四棱柱底面的长：" ;
	cin >>a; cout<<endl;
	cout << "输入四棱柱底面的宽：" ;
	cin >> b; cout <<endl;
}
float Rectangle :: area()const{
	return a*b;
}
float Rectangle ::girth()const{
	return 2*(a+b);
}
void Circle :: setcir(){
	cout <<"输入圆柱的半径：" ;
	cin >> a;cout<<endl;
}
float Circle :: area()const{
	return 3.14159*a*a;
}
float Circle :: girth()const{
	return 2*3.14159*a;
}
void Point ::setpoint(){
	cin >> x >>y;
}
void Triangle :: settri(){
	cout << "输入三棱柱底面顶点A的<x y>坐标：" ;
	A.setpoint();cout<<endl;
	cout << "输入三棱柱底面顶点B的<x y>坐标：" ;
	B.setpoint();cout<<endl;
	cout << "输入三棱柱底面顶点C的<x y>坐标：" ;
	C.setpoint();cout<<endl;
}
float Triangle :: area()const{
	float m;
	m=A.x*B.y+A.y*C.x+B.x*C.y-A.x*C.y-A.y*B.x-B.y*C.x;
	if(m>0) return m/2;
	else return -m/2;
}
float Triangle :: girth()const{
	return sqrt((A.x-B.x)*(A.x-B.x)+(A.y-B.y)*(A.y-B.y))+sqrt((C.x-B.x)*(C.x-B.x)+(C.y-B.y)*(C.y-B.y))+sqrt((A.x-C.x)*(A.x-C.x)+(A.y-C.y)*(A.y-C.y));
}

 
源码 main.cpp
 
#include <iostream>
#include "string"
#include "iquery.h"
#include "iomanip"
#include "cmath" 

/* run this program using the console pauser or add your own getch, system("pause") or input loop */
using namespace std;
int main(int argc, char** argv) {
	Body body;
	Circle c;
	Rectangle r;
	Triangle t;
	body.setpb(&c);
	c.setcir();
	cout << "输入圆柱体的高：";
	body.sethigh();
	cout<<"圆柱体的体积为："<<body.volume()<<endl;
	cout<<"圆柱体的表面积为："<<body.surfaceArea()<<endl;
	cout<<endl;
	body.setpb(&r);
	r.setrec();
	cout <<"输入四棱柱的高：";
	body.sethigh();
	cout<<"四棱柱的体积为："<<body.volume()<<endl;
	cout<<"四棱柱的表面积为："<<body.surfaceArea()<<endl;
	cout<<endl;
	body.setpb(&t);
	t.settri();
	cout << "输入三棱柱的高：";
	body.sethigh();
	cout<<"三棱柱的体积为："<<body.volume()<<endl;
	cout<<"三棱柱的表面积为："<<body.surfaceArea()<<endl; 
	return 0; 
}
 
注：
 已经出现过的error:
 
存在的问题：
 
注意cmath头文件
 
可行性优化：
 
使用构造函数对类对象进行初始化，同时注意纯虚函数的构造函数使用时的问题
 
 
欢迎访问陈风的个人博客

 
桂电C++面向对象程序设计实验: 实验六 多态性与虚函数

 
1.声明Point（点）类，由Point类派生出Circle（圆）类，再由Circle类派生出Cylinder（圆柱体）类。将类的定义部分分别作为3个头文件，对它们成员函数的声明部分分别作为3个源文件（.cpp文件），在主函数中用#include命令把它们包含进来，形成一个完整的程序，并上机运行。本题是《C++面向对象程序设计》第6章第1题。
 
2.在《C++面向对象程序设计》第6章例6.3的基础上作以下修改，并作必要的讨论。
 ① 把构造函数修改为带参数的函数，在建立对象时初始化。
 ② 先不将析构函数声明为virtual，在main函数中另设一个指向Circle类对象的指针变量，使它指向grad1。
 ③ 不作第②点的修改而将析构函数声明为virtual，运行程序，分析结果。
 本题是《C++面向对象程序设计》第6章第3题。
 
3.声明抽象基类Shape，由它派生出3个派生类：Circle（圆形）、Rectangle（矩形）、Triangle（三角形），用一个函数printArea分别输出以上三者的面积，3个图形的数据在定义对象时给定。本题是《C++面向对象程序设计》第6章第4题。
 
6.1 源码
 
"point.h"
 
#define POINT_H
#include <iostream>
using namespace std;
class Point
{
public:	
	Point(double x=0, double y=0);
	void setPoint(double, double);
	double getX() const{return x;}
	double getY() const{return y;}
	friend ostream & operator<<(ostream &, const Point &);
protected:
	double x, y;
};
#endif
 
"point.cpp"
 
#include"poin.h"
Point::Point(double a, double b)
{
	x=a; y=b;
}
void Point::setPoint(double a, double b)
{
	x=a; y=b;
}
ostream& operator<<(ostream &output, const Point &p)
{
	output<<"["<<p.x<<", "<<p.y<<"]"<<endl;
	return output;
}

#endif


 
"cricle.h"
 
#ifndef CIRCLE_H//circle.h
#define CIRCLE_H
#include"point.h"
class Circle: public Point
{
public:
	Circle (double x=0, double y=0, double r=0);
	void setRadius(double);
	double getRadius() const;
	double area() const;
	friend ostream& operator<<(ostream &, const Circle &);
protected:
	double radius;
};
 
"circle.cpp"
 
#include"circle.h"//circle.cpp
Circle::Circle(double a, double b, double r): Point(a, b), radius(r){}
void Circle::setRadius(double r){radius=r;}
double Circle::getRadius() const { return radius;}
double Circle::area() const {return 3.14159*radius*radius;}
ostream& operator<<(ostream &output, const Circle &c)
{
	output<<"Center=["<<c.x<<", "<<c.y<<"], r="<<c.radius<<", area="<<c.area()<<endl;
	return output;
}
#endif
 
"cylinder.h"
 
#ifndef CYLINDER_H//cylinder.h
#define CYLINDER_H
#include"point.h"
#include"circle.h"
class Cylinder: public Circle
{
public:
	Cylinder(double x=0, double y=0, double r=0, double h=0);
	void setHeight(double);
	double getHeight() const;
	double area() const;
	double volume() const;
	friend ostream& operator<<(ostream &, const Cylinder &);
protected:
	double height;
};
#endif

 
"cylinder.cpp"
 
#include"cylinder.h"//cylinder.cpp
Cylinder::Cylinder(double a, double b, double r, double h)
	:Circle(a, b, r), height(h){}
void Cylinder::setHeight(double h) {height=h;}
double Cylinder::getHeight() const {return height;}
double Cylinder::area() const {return 2*Circle::area()+2*3.14159*radius*height;}
double Cylinder::volume() const {return Circle::area()*height;}
ostream& operator<<(ostream &output, const Cylinder &cy)
{
	output<<"Center=["<<cy.x<<", "<<cy.y<<"], r="<<cy.radius<<", h="<<cy.height
		<<"\narea="<<cy.area()<<", volume="<<cy.volume()<<endl;
	return output;
}
 
"main.cpp"
 
#include"cylinder.h"//主函数
int main()
{
	Cylinder cy1(3.5, 6.4, 5.2, 10);
	cout<<"\noriginal cylinder:\nx="<<cy1.getX()<<", y="<<cy1.getY()<<", r="
		<<cy1.getRadius()<<", h="<<cy1.getHeight()<<"\narea="<<cy1.area()
		<<", volume="<<cy1.volume()<<endl;
	cy1.setHeight(15);
	cy1.setRadius(7.5);
	cy1.setPoint(5, 5);
	cout<<"\nnew cylinder:\n"<<cy1;
	Point &pRef=cy1;
	cout<<"\npRef as a Point:"<<pRef;
	Circle &cRef=cy1;
	cout<<"\nRef as a Circle:"<<cRef;
}
 
6.2 源码
 
#include<iostream>//2
using namespace std;
class Point
{
public:
	Point(float a,float b):x(a),y(b){}
	virtual ~Point(){cout<<"executing Point destructor"<<endl;}
private:
	float x;
	float y;
};
class Circle:public Point
{
public:
	Circle(float a,float b,float r):Point(a,b),radius(r){}	
	virtual ~Circle(){cout<<"executing Circle destructor"<<endl;}
private:
	float radius;
};
int main()
{
	Circle cr(2.5,1.8,4.5);
	Circle *p;
	p=&c1;
}
 
6.3 源码
 
#include<iostream>//3
#include<cmath>
using namespace std;
const double PI = 3.1415926;
class Shape
{
public:
	virtual double area()const = 0;
};
class Circle :public Shape
{
public:
	Circle(double r) :radius(r){}
	virtual double area()const{ return PI*radius*radius; };
protected:
	double	radius;
};
class Rectangle :public Shape
{
public:
	Rectangle(double c, double k) :chang(c), kuan(k){}
	virtual double area()const{ return chang*kuan; };
protected:
	double chang, kuan;
};
class Triangle :public Shape
{
public:
	Triangle(double a, double b, double c) :a(a), b(b), c(c),p((a+b+c)/2){}
	virtual double area()const{ return sqrt(p*(p - a)*(p - b)*(p - c)); };
protected:
	double a, b, c, p;
};
void print(const Shape &s)
{
	cout << s.area() << endl;
}
int main()
{
	Circle yuan(4.2);
	Rectangle jx(3.5, 4.2);
	Triangle sjx(3, 4, 5);
	cout << "圆的面积为:";
	print(yuan);
	cout << "矩形的面积为:";
	print(jx);
	cout << "三角形的面积为:";
	print(sjx);
}