C++：虚函数的详解

5.4.2 虚函数详解

1.虚函数的定义
虚函数就是在基类中被关键字virtual说明，并在派生类重新定义的函数。虚函数的作用是允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。

虚函数的定义是在基类中进行的，它是在基类中需要定义为虚函数的成员函数的声明中冠以关键字virtual。定义虚函数的格式如下：

virtual 函数类型 函数名(形参表)
{
     函数体
}
在基类中的某个成员函数声明为虚函数后，此虚函数就可以在一个或多个派生类中被重新定义。在派生类中重新定义时，其函数类型、函数名、参数个数、参数类型的顺序，都必须与基类中的原型完全相同。

//例 5.21 虚函数的使用

#include<iostream>
using namespace std;
class B0{
 public:
   virtual void print(char *p)      //定义基类B0中的虚函数
   {
     cout<<p<<"print()"<<endl;
   }
};
class B1:public B0{
  public:

    virtual void print(char *p)     //定义基类B0的公有派生类B1中的虚函数
    {
     cout<<p<<"print()"<<endl;
    }
};
class B2:public B1{
  public:
    virtual void print(char *p)     //定义基类B1的公有派生类B2中的虚函数
    {
     cout<<p<<"print()"<<endl;
    }
};
int main()
{
 B0 ob0,*op;                  //定义基类对象ob0和对象指针op
 op=&ob0;op->print("B0::");   //调用基类的B0的print()
 B1 ob1;                      //定义派生类B1的对象ob1
 op=&ob1;op->print("B1::");   //调用派生类B1的print()
 B2 ob2;                      //定义派生类B2的对象ob2
 op=&ob2;op->print("B2::");   //调用派生类B2的print()
 return ;
}
 /*
   在程序中，语句op->print()；
   出现了3次，由于op指向的对象不同，每次出现都执行了相应对象的虚函数print

   程序运行结果：
     B0::print()
     B1::print()
     B2::print()

说明：
（1）若在基类中，只是声明虚函数原型(需要加上virtual),而在类外定义虚函数时，则不必再加上virtual。

（2）在派生类中重新定义时，其函数类型、函数名、参数个数、参数类型的顺序，都必须与基类中的原型完全相同。

（3）C++规定，当一个成员函数被定义为虚函数后，其派生类中符合重新定义虚函数要求的同名函数都自动称为虚函数。因此，在派生类中重新定义该虚函数时，关键字virtual可写可不写。但是为了程序更加清晰，最好在每一层派生类中定义函数时都加上关键字virtual。

（4）如果在派生类中没有对基类的虚函数重新定义，则公有派生类继承其直接基类的虚函数。
一个虚函数无论被公有继承多少次。它仍然保持其虚函数的特性。
例如：
class B0{
      ...
      public:
              virtual void show(); //在基类中定义show为虚函数
};
class B1:public B0{
      ...
};
若在公有派生类B1中没有重新定义虚函数show，则函数在派生类中被继承，仍然是虚函数。
（5）虚函数必须是其所在类的成员函数，而不能是友元函数，也不能是静态成员函数，因为虚函数的调用要靠特定的对象来决定该激活哪个函数。

（6）虽然使用对象名和点运算符的方式也可以调用虚函数，但是这种调用是在编译时进行的，是静态联编，它没有利用虚函数的特性。只有通过指针访问虚函数时才能获得运行时的多态性。

2. 虚析构函数

在C++中，不能声明虚构造函数，但是可以声明虚析构函数。
//例5.23 虚析构函数的引例

#include<iostream>
using namespace std;
class B{
  public:
    ~B()
    {
     cout<<"调用基类B的析构函数\n";
    }
};
class D:public B{
  public:
    ~D()
    {
     cout<<"调用派生类D的析构函数\n";
    }
};
int main()
{
 D obj;
 return ;
}
*/
/*
运行结果是：
调用派生类D的析构函数
调用基类B的析构函数

显然本程序的运行结果是符和预想的。但是，如果在主函数中用new运算符建立一个无名对象
和定义了一个基类的对象指针，并将无名的对象的地址赋给这个对象指针。当用delete运算符
撤销无名对象时，系统只执行基类的析构函数，而不执行派生类的析构函数。
例如下面的例子：
*/

//例5.24 虚析构函数的引例2

#include<iostream>
using namespace std;
class B{
  public:
    ~B()
    {
     cout<<"调用基类B的析构函数\n";
    }
};
class D:public B{
  public:
    ~D()
    {
     cout<<"调用派生类D的析构函数\n";
    }
};
int main()
{
 B *p;          //定义指向基类B的指针变量p
 p = new D;     //用new运算符为派生类的无名对象动态的分配了一个存储空间，并将地址赋给对象指针p
 delete p;      //用delete撤销无名对象时，释放动态存储空间
 return ;
} 
/*
程序运行结果：
调用基类B的析构函数

程序结果表示，本程序只执行了基类B的析构函数，而没有执行派生类D的析构函数。
原因是:当撤销指针p所指的派生类的无名对象，而调用析构函数时，采用了静态联编方式，
只调用了基类B的析构函数。

那么如何在撤销指针p所指的派生类的无名对象，既调用基类B的析构函数，也调用派生类D的
析构函数呢？

方法是：可以将基类的析构函数声明为虚析构函数，采用了多态性的动态联编方式。

虚析构函数没有类型，也没有参数，和普通虚函数相比，虚析构函数比较简单。
其声明格式： virtual ~类名()
*/

//例5.25 虚析构函数的使用

#include<iostream>
using namespace std;
class B{
  public:
    virtual ~B()
    {
     cout<<"调用基类B的析构函数\n";
    }
};
class D:public B{
  public:
    ~D()
    {
     cout<<"调用派生类D的析构函数\n";
    }
};
int main()
{
 B *p;          //定义指向基类B的指针变量p
 p = new D;     //用new运算符为派生类的无名对象动态的分配了一个存储空间，并将地址赋给对象指针p
 delete p;      //用delete撤销无名对象时，释放动态存储空间
 return ;
}
/*
程序运行结果是：
调用派生类D的析构函数
调用基类B的析构函数

   说明：虽然派生类的析构函数与基类的析构函数名字不相同，但是如果将基类的析构函数
         定义为虚函数，则由该基类所派生的所有派生类的析构函数也都自动成为虚函数。
*/ 

3.虚函数与重载函数的关系
在一个派生类中重新定义基类的虚函数是函数重载的另一种形式，但它不同于一般函数重载。
当普通的函数重载时，其函数的参数或参数类型有所不同，函数的返回类型也可以不同。但是当重载一个虚函数时，也就是说在派生类中重新定义虚函数时，要求函数名、返回类型、参数个数、参数的类型和顺序与基类的虚函数原型完全相同。如果仅仅返回类型不同，其余均相同，系统会给出错误信息；若仅仅函数名相同，而参数的个数、类型或顺序不同，系统将它作为普通的函数重载，这时虚函数的特性将丢失。

//例5.26 虚函数与重载函数的关系

#include<iostream>
using namespace std;
class Base{
 public:
   virtual void func1();
   virtual void func2();
   virtual void func3();
   void func4();
};
class Derived:public Base{
 public:
   virtual void func1();     //func1是虚函数，这里可以不写virtual
   void func2(int i);        //与基类中的func2作为普通函数的重载，虚特性消失
   //char func3();           //错误，因为与基类的func3返回类型不同，应删去
   void func4();             //与基类中的func4是普通函数的重载，不是虚函数
};
void Base::func1()
{
 cout<<"--Base func1--\n";
}
void Base::func2()
{
 cout<<"--Base func2--\n";
}
void Base::func3()
{
 cout<<"--Base func3--\n";
}
void Base::func4()
{
 cout<<"--Base func4--\n";
}
void Derived::func1()
{
 cout<<"--Derived func1--\n";
}
void Derived::func2(int i)
{
 cout<<"--Derived func2--\n";
}
void Derived::func4()
{
 cout<<"--Derived func4--\n";
}
int main()
{
 Base b,*pt;    //定义基类的对象b和对象指针pt
 Derived d;     //定义派生类的对象d
 pt = &d;       //基类的指针pt象派生类的对象d
 pt->func1();   //调用的是派生类的fun1，结果是--Derived func1-- (虚函数的特性)
 pt->func2();   //调用的是基类的fun2,结果是--Base func2--(参数表中多了一个参数,变成普通重载函数,丢失虚函数的特性)
 pt->func4();   //调用的是基类的fun4，结果是--Base func4--(基类和派生类中均没有virtual关键字，普通成员函数的重载)
 return ;
}
/*
程序运行结果是：
--Derived func1--
--Base func2--
--Base func4--
*/

4. 多重继承与虚函数

//例5.27 多重继承与虚函数的例子

#include<iostream>
using namespace std;
class Base1{
  public:
   virtual void fun()           //定义fun是虚函数
   {
    cout<<"--Base1--\n";
   }
};
class Base2{
  public:
   void fun()                  //定义fun是普通的成员函数
   {
    cout<<"--Base2--\n";
   }
};
class Derived:public Base1,public Base2{
  public:
   void fun()
   {
    cout<<"--Derived--\n";
   }
};
int main()
{
 Base1 *ptr1;
 Base2 *ptr2;
 Derived d;
 ptr1 = &d;  //基类的指针指向派生类的对象
 ptr1->fun();/*(*ptr1).fun();*/  //调用派生类Derived的fun方法，因为它是由Base1派生来的，为虚函数，有虚特性
 ptr2->fun();/*(*ptr2).fun();*/  //调用基类Base2的fun方法，派生类的fun方法是由Base2派生类来的，为普通成员重载函数 

 Derived obj;//基类的引用指向派生类的对象
 Base1 &p1 = obj;
 Base2 &p2 = obj;
 p1.fun();//调用派生类Derived的fun方法，因为它是由Base1派生来的，为虚函数，有虚特性
 p2.fun();//调用基类Base2的fun方法，派生类的fun方法是由Base2派生类来的，为普通成员重载函数,无虚特性 

 return ;
}

5.虚函数的综合应用

//例5.28 应用C++的多态性，计算三角形、矩形和圆的面积。

#include<iostream>
#define PI 3.1416
using namespace std;
class Shape{                    //定义一个公共的基类
   public:
   // Shape(){}
    Shape(double a=0.0,double b=0.0)  //带默认的构造函数
    {
     x = a;
     y = b;
    }
    virtual void area()
    {
     cout<<"在基类中定义的虚基类";
     cout<<"为派生类提供一个公共的接口,";
     cout<<"以便派生类根据需要重新定义虚函数"<<endl;
    }
   protected:
    double x;
    double y;
};
class Triangle:public Shape{     //定义一个三角形的派生类
  public:
     Triangle(double a,double b):Shape(a,b){}
     void area()
     {
       cout<<"三角形的高是:"<<x<<","<<"底是:"<<y<<endl;
       cout<<"三角形面积:"<<0.5*x*y<<endl;
     }
};
class Square:public Shape{     //定义一个矩形的派生类
  public:
     Square(double a,double b):Shape(a,b){}
     void area()
     {
       cout<<"矩形的长是:"<<x<<","<<"宽是:"<<y<<endl;
       cout<<"矩形面积:"<<x*y<<endl;
     }
};
class Circle:public Shape{     //定义一个圆的派生类
  public:
     Circle(double a):Shape(a,a){}
     void area()
     {
       cout<<"圆的半径是:"<<x/<<endl;
       cout<<"圆面积:"<<PI*x*x<<endl;
     }
};
int main()
{
 Shape *p,obj;                     //定义基类的对象指针p和对象obj
 p=&obj;                           //基类的对象指针p指向基类的对象obj
 p->area();                        //调用基类的area方法
 Triangle t(10.0,6.0);             //定义三角形的对象t
 Square s(10.0,6.0);               //定义矩形的对象s
 Circle c(10.0);                   //定义圆形的对象t
 p=&t;
 p->area();                        //计算三角形的面积
 p=&s;
 p->area();                        //计算矩形的面积
 p=&c;
 p->area();                        //计算圆形的面积
 return ;
}
/*
 程序运行结果:
 在基类中定义的虚基类为派生类提供一个公共的接口,以便派生类根据需要重新定义虚函数
三角形的高是:10,底是:6
三角形面积:30
矩形的长是:10,宽是:6
矩形面积:60
圆的半径是:
圆面积:314.16
*/