一个C++的多态和虚函数实例

类的说明：

code：

#include<iostream>
#include<string>
#define PAI 3.1415926
using namespace std;
class Shape			//抽象类
{
	public:
		virtual float area() const //计算面积
		{
			return 0.0;
		}
		virtual float volume() const//计算体积
		{
			return 0.0;
		}
		virtual void ShapeName() const =0;//纯虚函数 ——形状名
};
//声明点类
class Point: public Shape
{
	public:
		Point(float =0,float =0);
		void setPoint(float,float);
		float getX()const {return x;}
		float getY()const {return y;}
		virtual void ShapeName()const
		{
			cout<<"Point:";
		}
		friend ostream &operator<< (ostream &,const Point &);
	protected:
		float x,y;
};
//对点类的函数进行类外定义
Point::Point(float a,float b)
{
	x=a;
	y=b;
}
void Point::setPoint(float a,float b)
{
	x=a;
	y=b;
}
ostream &operator<<(ostream &output,const Point&b)
{
	output<<"["<<b.x<<","<<b.y<<"]"<<endl;
	return output;
}
//声明圈类
class Circle:public Point
{
	public:
		Circle(float x=0,float y=0,float r=0);
		void setRadius(float);
		float GetRadius()const;
		virtual float area() const;
		virtual void ShapeName()const
		{
			cout<<"Circle:";
		}
		friend ostream &operator<< (ostream &,const Circle &);
	protected:
		float radius;
};
//对圈内的函数进行类外定义
Circle::Circle(float x,float y,float r):Point(x,y),radius(r){}
void Circle::setRadius(float r)
{
	radius=r;
}
float Circle::GetRadius()const
{
	return radius;
}
float Circle::area()const
{
	return PAI*radius*radius;
}
ostream &operator<<(ostream &output,const Circle &c)
{
	output<<"["<<c.x<<","<<c.y<<"],r="<<c.radius<<endl;
	return output;
}
//声明圆柱类
class Cylinder:public Circle
{
	public:
		Cylinder(float x=0,float y=0,float r=0,float h=0);
		void setHeight(float h);
		virtual float area()const;
		virtual float volume()const;
		virtual void ShapeName()const
		{
			cout<<"Cylinder:";
		}
		friend ostream &operator<< (ostream &,const Cylinder&);
	protected:
		float height;
};
//对圆柱类中的函数进行类外定义
Cylinder::Cylinder(float x,float y,float r,float h)
	:Circle(x,y,r),height(h){}//对于多层继承，只需要给其直接基类传值
void Cylinder::setHeight(float h)
{
	height=h;
}
float Cylinder::area()const
{
	return PAI*radius*radius;
}
float Cylinder::volume()const
{
	return PAI*radius*radius*height;
}
ostream &operator <<(ostream &output,const Cylinder&c)
{
	output<<"["<<c.x<<","<<c.y<<"],r="<<c.radius<<",h="<<c.height<<endl;
	return output;
}
int main()
{
	Point point(3.2,4.5);
	Circle circle(2.4,1.2,5.6);
	Cylinder cylinder(3.5,6.4,5.2,10.5);
	point.ShapeName();		//静态关联
	cout<<point<<endl;
	circle.ShapeName(); 	//静态关联
	cout<<circle<<endl;
	cylinder.ShapeName();	//静态关联
	cout<<cylinder<<endl; 

	Shape *pt;				//定义基类指针pt

	pt=&point;				//指针指向point
	pt->ShapeName();		//动态关联
	cout<<"x="<<point.getX()<<",y="<<point.getY()<<"\narea="<<pt->area()
		<<"\nvolume="<<pt->volume()<<endl<<endl; 

	pt=&circle;				//指针指向Circle
	pt->ShapeName();		//动态关联
	cout<<"x="<<circle.getX()<<",y="<<circle.getY()<<"\narea="<<pt->area()
		<<"\nvolume="<<pt->volume()<<endl<<endl; 

	pt=&cylinder;			//指针指向cylinder
	pt->ShapeName();		//动态关联
	cout<<"x="<<cylinder.getX()<<",y="<<cylinder.getY()<<"\narea="<<pt->area()
		<<"\nvolume="<<pt->volume()<<endl<<endl;
	cout<<endl;
	return 0;
}

Shape是图形类，它是所有图形的一个概述，抽象了图形的名称，面积，体积函数，并定义为虚函数。因为每一个图形都应该有个名字，所以声明ShapeName函数为纯虚函数，而面积和体积等特性并不一定是每一个图形都具有的特征，所以默认置零。

Point类继承自Shape，它定义了纯虚函数ShapeName，然后添加了自己的setPoint,getX,getY成员函数，并重载了输出流运算符用于Point类的输出。

Circle类继承自Point，它定义了纯虚函数ShapeName，以及虚函数area，然后添加了自己的setRadius，getRadius成员函数，并重载了输出流运算符用于Circle类的输出。

Cylinder类继承自Circle，它定义了纯虚函数ShapeName，以及虚函数area，和volume，然后添加了自己的setHeight成员函数，并重载了输出流运算符用于Cylinder的输出。

区别静态关联和动态关联：

如果是通过对象名调用虚函数（如point.ShapeName()），在编译阶段就能确定调用的是那一个类的虚函数，所以属于静态关联。

如果是通过基类指针调用虚函数（如pt->volume()），在编译阶段无法从语句本身确定是那一个类的虚函数，只有在运行时，pt指向某一类对象后，才能确定调用的是那一个类的虚函数，故为动态关联。