C++学习笔记——多态性与虚函数

多态性概念

在C ++程序设计中，多态性是指具有不同功能的函数可以用同一个函数名，这样就可以用一个函数名调用不同内容的函数。在面向对象方法中一般是这样表述多态性的：向不同的对象发送同一个消息， 不同的对象在接收时会产生不同的行为（即方法）。也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

从系统实现的角度看，多态性分为两类：静态多态性和动态多态性。以前学过的函数重载和运算符重载实现的多态性属于静态多态性，在程序编译时系统就能决定调用的是哪个函数，因此静态多态性又称编译时的多态性。静态多态性是通过函数的重载实现的（运算符重载实质上也是函数重载）。动态多态性是在程序运行过程中才动态地确定操作所针对的对象。它又称运行时的多态性。动态多态性是通过虚函数（Virtual fiinction)实现的。

多态性的一个典型例子

[例12.1] 先建立一个Point(点)类，包含数据成员x,y(坐标点)。以它为基类，派生出一个Circle(圆)类，增加数据成员r(半径)，再以Circle类为直接基类，派生出一个Cylinder(圆柱体)类，再增加数据成员h(高)。要求编写程序，重载运算符“<<”和“>>”，使之能用于输出以上类对象。

1) 声明基类Point

#include <iostream>
//声明类Point
class Point
{
public:
   Point(float x=0,float y=0);  //有默认参数的构造函数
   void setPoint(float ,float);  //设置坐标值
   float getX( )const {return x;}  //读x坐标
   float getY( )const {return y;}  //读y坐标
   friend ostream & operator <<(ostream &,const Point &);  //重载运算符“<<”
protected:  //受保护成员
   float x, y;
};
//下面定义Point类的成员函数
Point::Point(float a,float b) //Point的构造函数
{  //对x,y初始化
   x=a;
   y=b;
}
void Point::setPoint(float a,float b) //设置x和y的坐标值
{  //为x,y赋新值
   x=a;
   y=b;
}
//重载运算符“<<”，使之能输出点的坐标
ostream & operator <<(ostream &output, const Point &p)
{
   output<<"["<<p.x<<","<<p.y<<"]"<<endl;
   return output;
}

2)声明派生类Circle

class Circle:public Point  //circle是Point类的公用派生类
{
public:
   Circle(float x=0,float y=0,float r=0);  //构造函数
   void setRadius(float );  //设置半径值
   float getRadius( )const;  //读取半径值
   float area ( )const;  //计算圆面积
   friend ostream &operator <<(ostream &,const Circle &);  //重载运算符“<<”
private:
   float radius;
};
//定义构造函数，对圆心坐标和半径初始化
Circle::Circle(float a,float b,float r):Point(a,b),radius(r){}
//设置半径值
void Circle::setRadius(float r){radius=r;}
//读取半径值
float Circle::getRadius( )const {return radius;}
//计算圆面积
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;
}

3) 声明Circle的派生类Cylinder

class Cylinder:public Circle// Cylinder是Circle的公用派生类
{
public:
   Cylinder (float x=0,float y=0,float r=0,float h=0);  //构造函数
   void setHeight(float );  //设置圆柱高
   float getHeight( )const;  //读取圆柱高
   loat area( )const;  //计算圆表面积
   float volume( )const;  //计算圆柱体积
   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){}
//设置圆柱高
void Cylinder::setHeight(float h){height=h;}
//读取圆柱高
float Cylinder::getHeight( )const {return height;}
//计算圆表面积
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;
} //重载运算符“<<”

虚函数、虚函数的作用和使用方法

虚函数的作用是允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。

#include <iostream>
#include <string>
using namespace std;
//声明基类Student
class Student
{
public:
    Student(int, string, float);  //声明构造函数
    virtual void display();//声明输出函数为虚函数
protected:  //受保护成员，派生类可以访问
    int num;
    string name;
    float score;
};
//Student类成员函数的实现
Student::Student(int n, string nam, float s)//定义构造函数
{
    num = n;
    name = nam;
    score = s;
}
void Student::display()//定义输出函数
{
    cout << "num:" << num << "\nname:" << name << "\nscore:" << score << "\n\n";
}
//声明公用派生类Graduate
class Graduate :public Student
{
public:
    Graduate(int, string, float, float);//声明构造函数
    void display();//声明输出函数
private:float pay;
};
// Graduate类成员函数的实现
void Graduate::display()//定义输出函数
{
    cout << "num:" << num << "\nname:" << name << "\nscore:" << score << "\npay=" << pay << endl;
}
Graduate::Graduate(int n, string nam, float s, float p) :Student(n, nam, s), pay(p){}
//主函数
int main()
{
    Student stud1(1001, "Li", 87.5);//定义Student类对象stud1
    Graduate grad1(2001, "Wang", 98.5, 563.5);//定义Graduate类对象grad1
    Student *pt = &stud1;//定义指向基类对象的指针变量pt
    pt->display();
    pt = &grad1;
    pt->display();
    system("pause");
    return 0;
}

输出结果：

num:1001
name:Li
score:87.5

num:2001
name:Wang
score:98.5
pay=563.5

可以看到：当把基类的某个成员函数声明为虚函数后，允许在其派生类中对该函数重新定义，赋予它新的功能，并且可以通过指向基类的指针指向同一类族中不同类的对象，从而调用其中的同名函数。

虚函数的使用方法是：

1. 在基类用virtual声明成员函数为虚函数。
2. 在派生类中重新定义此函数，要求函数名、函数类型、函数参数个数和类型全部与基类的虚函数相同，并根据派生类的需要重新定义函数体。C++规定，当一个成员函数被声明为虚函数后，其派生类中的同名函数都自动成为虚函数。
3. 定义一个指向基类对象的指针变量，并使它指向同一类族中需要调用该函数的对象。
4. 通过该指针变量调用此虚函数，此时调用的就是指针变量指向的对象的同名函数。

静态关联与动态关联、C++是怎样实现多态性的

确定调用的具体对象的过程称为关联(binding)。

前面所提到的函数重载和通过对象名调用的虚函数，在编译时即可确定其调用的虚函数属于哪一个类，其过程称为静态关联(static binding)，由于是在运行前进行关联的， 故又称为早期关联(early binding)。函数重载属静态关联。

在运行阶段，基类指针变量先指向了某一个类对象，然后通过此指针变量调用该对象中的函数。此时调用哪一个对象的函数无疑是确定的。例如，先使pt指向grad1，再执行“pt->display()”，当然是调用grad1中的display函数。由于是在运行阶段把虚函数和类对象“绑定”在一起的，因此，此过程称为动态关联(dynamic binding)。

在什么情况下应当声明虚函数

使用虚函数时，有两点要注意：

1. 只能用virtual声明类的成员函数，使它成为虚函数，而不能将类外的普通函数声明为虚函数。因为虚函数的作用是允许在派生类中对基类的虚函数重新定义。显然，它只能用于类的继承层次结构中。
2. 一个成员函数被声明为虚函数后，在同一类族中的类就不能再定义一个非virtual的但与该虚函数具有相同的参数(包括个数和类型)和函数返回值类型的同名函数。

根据什么考虑是否把一个成员函数声明为虚函数呢？主要考虑以下几点：

1. 首先看成员函数所在的类是否会作为基类。然后看成员函数在类的继承后有无可能被更改功能，如果希望更改其功能的，一般应该将它声明为虚函数。
2. 如果成员函数在类被继承后功能不需修改，或派生类用不到该函数，则不要把它声明为虚函数。不要仅仅考虑到要作为基类而把类中的所有成员函数都声明为虚函数。
3. 应考虑对成员函数的调用是通过对象名还是通过基类指针或引用去访问，如果是通过基类指针或引用去访问的，则应当声明为虚函数。
4. 有时，在定义虚函数时，并不定义其函数体，即函数体是空的。它的作用只是定义了一个虚函数名，具体功能留给派生类去添加。

虚析构函数详解

如果用new运算符建立了临时对象，若基类中有析构函数，并且定义了一个指向该基类的指针变量。在程序用带指针参数的delete运算符撤销对象时，会发生一个情况：系统会只执行基类的析构函数，而不执行派生类的析构函数。

#include <iostream>
using namespace std;
class Point  //定义基类Point类
{
public:
   Point( ){}  //Point类构造函数
   ~Point(){cout<<"executing Point destructor"<<endl;}  //Point类析构函数
};
class Circle:public Point  //定义派生类Circle类
{
public:
   Circle( ){}  //Circle类构造函数
   ~Circle( ){cout<<"executing Circle destructor"<<endl;}  //Circle类析构函数
private:
   int radius;
};
int main( )
{
   Point *p=new Circle;  //用new开辟动态存储空间
   delete p;  //用delete释放动态存储空间
   return 0;
}

运行结果为：

executing Point destructor

如果希望能执行派生类Circle的析构函数，可以将基类的析构函数声明为虚析构函数，如：

    virtual ~Point(){cout<<″executing Point destructor″<<endl;}

如果将基类的析构函数声明为虚函数时，由该基类所派生的所有派生类的析构函数也都自动成为虚函数，即使派生类的析构函数与基类的析构函数名字不相同。

构造函数不能声明为虚函数。这是因为在执行构造函数时类对象还未完成建立过程，当然谈不上函数与类对象的绑定。

纯虚函数详解

纯虚函数是在声明虚函数时被“初始化”为0的函数。声明纯虚函数的一般形式是

    virtual 函数类型 函数名 (参数表列) = 0;

关于纯虚函数需要注意的几点：
1. 纯虚函数没有函数体；
2. 最后面的“=0”并不表示函数返回值为0，它只起形式上的作用，告诉编译系统“这是纯虚函数”;
3. 这是一个声明语句，最后应有分号。
4. 如果在一个类中声明了纯虚函数，而在其派生类中没有对该函数定义，则该虚函数在派生类中仍然为纯虚函数。

抽象类

这种不用来定义对象而只作为一种基本类型用作继承的类，称为抽象类(abstract class )，由于它常用作基类，通常称为抽象基类(abstract base class )。凡是包含纯虚函数的类都是抽象类。因为纯虚函数是不能被调用的，包含纯虚函数的类是无法建立对象的。