多态性与虚函数
2011年08月22日

多态性与虚函数       

      面向对象理论中的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!

专业人员一般都习惯声明虚析构函数,即使基类并不需要析构函数,也显式地定义一个函数体为空的析构函数,以保证在撤销动态存储空间时能得到正确的处理。