多态性与虚函数
面向对象理论中的3个术语：对象、方法和消息。对象（object）：不言而喻，它是构成系统的基本单位，有属性和行为两个要素，在C++中，每个对象都是由数据和函数这两部分组成的，数据即是对象的属性，行为称之为方法（method），方法是对数据的操作，通常由函数实现。调用对象中的函数就是向该对象传送一个消息（message），所谓“消息”，其实就是一个命令。例如：
stud.display();
就是向对象stud发出的一个“消息”，通知它执行其中的display“方法”（即display函数）。即：stud是对象，display()是方法，语句“stud.display();”是消息。
1.多态性（polymorphism）
多态性定义：由继承而产生的相关的不同的类，向其对象发送同一个消息，不同的对象接收到后会产生不同的行为（即方法）。
多态性分为两类：静态多态性和动态多态性。函数重载和运算符重载实现的多态性属于静态多态性，在程序编译时系统就能决定调用的是哪个函数，因此静态多态性有称为编译时的多态性。静态多态性是通过函数的重载实现的（运算符重载实质上也是函数重载）。动态多态性是在程序运行过程中才动态地确定操作所针对的对象，故称之为运行时的多态性。动态多态性是通过虚函数实现的。
关于静态多态性和动态多态性，请看下面的例子：
定义3个类：点、圆和圆柱
#include <iostream.h>
//定义Point基类
class Point
{
public:
Point(float=0, float=0);
void display();
friend ostream & operator <<(ostream &, const Point &);
protected:
float x, y;
};
Point::Point(float a, float b)
{
x=a; y=b;
}
ostream & operator <<(ostream &output, const Point &p)
{
output<<"["<<p.x<<","<<p.y<<"]"<<endl;
return output;
}
void Point::display()
{
cout<<"["<<x<<","<<y<<"]"<<endl;
}
//定义Circle基类
class Circle: public Point
{
public:
Circle(float=0, float=0, float=0);
float area ( ) const;
void display();
friend ostream & operator <<(ostream &, const Circle &);
protected:
float radius;
};
Circle::Circle(float a,float b,float r):Point(a,b),radius(r){ }
float 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;
}
void Circle::display()
{
cout<<"Center=["<<x<<","<<y<<"], r="<<radius<<", area="<<area( )<<endl;
}
//定义圆柱体类
class Cylinder: public Circle
{
public:
Cylinder (float=0,float=0,float=0,float=0);
float area() const;//计算圆表面积，和Circle类中的area重名
float volume() const;
void display();
friend ostream & operator <<(ostream &, const Cylinder &);
protected:
float height;
};
Cylinder::Cylinder(float a,float b,float r,float h):Circle(a,b,r),height(h){}
float Cylinder::area( ) const
{ return 2*Circle::area()+2*3.14159*radius*height; }
float 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;
}
void Cylinder::display()
{
cout<<"Center=["<<x<<","<<y<<"], r="<<radius<<", h="
<<height<<"\narea="<<area( )<<", volume="<<volume( )<<endl;
}主函数(1)，静态关联
int main()
{
Cylinder cy1;
cout<<"A Cylinder:\n"<<cy1; //用重载运算符“<<”输出cy1的数据
Point &p=cy1; //将圆柱cy1赋值给点，p是Point类对象的引用变量
cout<<"\np as a Point:\n"<<p; //p作为一个“点”输出
Circle &c=cy1; //将圆柱cy1赋值给圆，c是Circle类对象的引用变量
cout<<"\nc as a Circle:\n"<<c<<endl; //c作为一个“圆”输出
return 0;
}由该主函数可知：1. 圆柱对象cy1可以直接赋值给其基类的对象；2. Circle类和Cylinder类中都有一个area( )函数，之所以在Cylinder中用area( )能直接调用Cylinder::area( )而没有调用Circle:: area( )是因为“同名覆盖”的缘故，默认Cylinder中的area( )覆盖了基类中的area( )函数（如果不想覆盖，可以用纯虚函数，能够对基类函数重新定义，但是哪个效果更高还不好说）。3. 三个类中都包含了同名的重载运算符“<<”函数，但是他们的第二个参数类型互不相同，所以不能看做是同名覆盖，实际上，是属于静态关联。“<<”运算符之所以能准确地调用不同类中的重载函数，是因为系统在编译时就已经确定了调用对象。
主函数(2)，动态关联：
int main( )
{
Point p1(9,9);
Circle c1(6,6,8);
Cylinder cy1(5,5,15,7.5);
Point *pt=&p1;
pt->display();
pt=&c1;
pt->display();
pt=&cy1;
pt->display();
return 0;
}首先应该明确一点：定义为指向Point基类对象的指针，当改变方向，指向派生类对象后，它仅指向派生类对象中基类的部分对象（例如当pt=&c1后，调用pt->display()相当于调用pt->Point::display()），所以上面调用的display()函数只能输出基类对象的值（即：定义为Point类型的指针pt根本就无法指向派生类增加的数据或函数，例如pt-> Circle::display()就会出错，提示“'Circle' : is not a memberof 'Point'”）。
要想pt能指向Circle::display()，就必须用虚成员函数来实现，即把基类中的display()函数声明为virtual类型。基类中的display()函数声明为了virtual类型，代表了它可以在派生类中被重新定义，为它赋予新功能（所以可以基类中的虚函数的函数体可以为空，或者写成纯虚函数的形式），注意是“重新定义”而不是“共存”，即此时Circle中定义的display()函数不再看做是增加的部分，而是看做基类的部分，所以直接用pt->display()或者pt->Point::display()就可以调用Circle类中定义的display()函数了，写成pt-> Circle::display()反而会出错。
2. 虚函数
上面已经说了，C++的动态多态性是通过虚函数来实现的。“虚成员函数”简称“虚函数”，C++不允许在类外声明虚函数。“虚函数允许派生类取代基类所提供的实现。编译器确保当对象为派生类时，取代者（译注：即派生类的实现）总是被调用，即使对象是使用基类指针访问而不是派生类的指针。”
上面的例子，写成虚函数的形式：
class
{
…
virtual void display(){} //声明为空的虚函数
}
int mai()
{
Point p1(9,9);
Circle c1(6,6,8);
Cylinder cy1(5,5,15,7.5);
Point *pt=&p1;
pt->display(); //错误，因为Point类中的display()被定义为空，没有输出功能
pt=&c1;
pt->display(); //直接调用就可以输出圆的内容了
……
}也可以写成纯虚函数的形式：
class
{
…
virtual void display() =0; //声明为纯虚函数
}
int mai()
{
Point p1(9,9); //错误，包含纯虚函数的类被成为抽象类，不能被初始化
Circle c1(6,6,8);
Cylinder cy1(5,5,15,7.5);
Point *pt=&p1;
pt->display();
pt=&c1;
pt->display(); //直接调用就可以了
……
}因为纯虚函数“徒有其名，而无其实”，所以包含纯虚函数的类都只作为基类，相当于提供一种基本的类型，它的不能被初始化，这种类被称为“抽象基类”，它总是被调用的。
例如，可以给点、圆和圆柱体定义一个抽象基类Shape（形状）：
class Shape
{
public:
virtual float area() const { return 0.0; } //虚函数
virtual float volume() const { return 0.0; } //虚函数
virtual void shapeName() const =0; //纯虚函数
};3. 虚析构函数
如果用new运算符建立了临时对象，若基类中有析构函数，并且定义了一个指向该基类的指针变量。在程序用带指针参数的delete运算符撤销对象时，会发生一个情况：系统会只执行基类的析构函数，而不执行派生类的析构函数。例如：
#include <iostream.h>
//定义Point基类
class Point
{
public:
Point( ){ }; //定义构造函数
~Point() { cout<<"Point OK!"<<endl; } //析构函数
};
class Circle: public Point
{
public:
Circle( ){ };
~Circle() { cout<<"Circle OK!"<<endl; }
protected:
float radius;
};
int main( )
{
Point *p=new Circle;
delete p;
return 0;
}希望用delete释放p所指的空间，但运行结果却为：
Point OK!
表示只执行了基类Piont的析构函数，而没有执行派生类Circle的析构函数。如果希望能执行派生类中的析构函数，可以将基类的析构函数声明为虚函数，如
virtual ~ Point() { cout<<"PointOK!"<<endl; }
如果将基类的析构函数声明为虚函数，由该基类所派生的所有派生类的析构函数也自动成为虚函数，即使它们名字不同。可见原理和格式与上面所说的虚函数是一样的。运行结果为：
Point OK!
Circle OK!
专业人员一般都习惯声明虚析构函数，即使基类并不需要析构函数，也显式地定义一个函数体为空的析构函数，以保证在撤销动态存储空间时能得到正确的处理。