11_2、多态性：虚函数

虚函数与抽象类

• 虚函数
• • 概念
  • 声明
  • 虚析构函数
• 抽象类
• • 纯虚函数
  • 抽象类

虚函数

概念

在赋值兼容规则中，基类类型的指针指向派生类对象时，通过此指针只能访问从基类继承来的同名成员。
如果我们希望通过指向派生类对象的基类指针，访问派生类中的同名成员该怎么办呢？

就要用到虚函数了。我们在基类中将某个函数声明为虚函数，就可以通过指向派生类对象的基类指针访问派生类中的同名成员了。这样使用某基类指针指向不同派生类的不同对象时，就可以发生不同的行为，也就实现了运行时的多态（编译时并不知道调用的是哪个类的成员）。

• 虚函数是动态绑定的基础。记住，虚函数是非静态的成员函数，一定不能是静态（static）的成员函数。虚函数在以后我们进行软件架构设计时会起到很关键的作用。

声明

一般的虚函数声明形式为：

virtual 函数类型 函数名(形参表)
{
   函数体
}

• 虚函数就是在类的声明中用关键字virtual限定的成员函数。以上声明形式是成员函数的实现也在类的声明中的情况。如果成员函数的实现在类的声明外给出时，则虚函数的声明只能出现在类的成员函数声明中，而不能在成员函数实现时出现，简而言之，只能在此成员函数的声明前加virtual修饰，而不能在它的实现前加。

运行多态时的条件：

1. 类之间要满足赋值兼容规则；
2. 要声明虚函数；
3. 通过类的对象的指针、引用访问虚函数或者通过类的成员函数调用虚函数。

#include <iostream>        
using namespace std;
class Base           // 基类Base的声明
{
public:
    virtual void show() { cout << "Base::show()" << endl; }      // 虚成员函数show
};
class Child0 : public Base     // 类Base的公有派生类Child0的声明
{
public:
    void show() { cout << "Child0::show()" << endl; }    // 虚成员函数show
};
class Child1 : public Child0   // 类Child0的公有派生类Child1的声明
{
public:
    void show() { cout << "Child1::show()" << endl; }    // 虚成员函数show
};
void CallShow(Base* pBase)     // 一般函数，参数为基类指针
{
    pBase->show();
}
int main()
{
    Base base;                 // 声明Base类的对象
    Base* pBase;             // 声明Base类的指针
    Child0 ch0;                 // 声明Child0类的对象
    Child1 ch1;                 // 声明Child1类的对象
    pBase = &base;        // 将Base类对象base的地址赋值给Base类指针pBase
    CallShow(pBase);
    pBase = &ch0;            // 将Child0类对象ch0的地址赋值给Base类指针pBase
    CallShow(pBase);
    pBase = &ch1;            // 将Child1类对象ch1的地址赋值给Base类指针pBase
    CallShow(pBase);
    return 0;
}

• 类Base、Child0和Child1属于同一个类族，而且Child0是由Base公有派生的，Child1是从Child0公有派生的，所以满足赋值兼容规则，这就符合了运行时多态的第一个条件。基类Base的函数show声明为了虚函数，这是第二个条件。在CallShow函数中通过对象指针pBase来访问虚函数show，这又满足了第三个条件。这个动态绑定过程在运行时完成，实现了运行时的多态。这样通过基类指针就可以访问指向的不同派生类的对象的成员，这在软件开发中不仅使代码整齐简洁，而且也大大提高了开发效率。

总分的编程思路，只用确定基类的主要功能，然后在派生类中阐述功能特点，通过基类的函数成员访问即可。

虚析构函数

不能声明虚构造函数，而可以声明虚析构函数。

多态是指不同的对象接收了同样的消息而导致完全不同的行为，它是针对对象而言的，虚函数是运行时多态的基础，当然也是针对对象的，而构造函数是在对象生成之前调用的，即运行构造函数时还不存在对象，那么虚构造函数也就没有意义了。

析构函数用于在类的对象消亡时做一些清理工作，我们在基类中将析构函数声明为虚函数后，其所有派生类的析构函数也都是虚函数，使用指针引用时可以动态绑定，实现运行时多态 ，通过基类类型的指针就可以调用派生类的析构函数对派生类的对象做清理工作。

析构函数没有返回值类型，没有参数表，所以虚析构函数的声明也比较简单，形式如下：

virtual ~类名();

抽象类

抽象类的定义就是，含有纯虚函数的类。

抽象类可以为某个类族提供统一的操作接口。其特点为：

1. 外部可以透明的使用抽象类的统一接口，而不需要知道到底是调用的抽象类的哪个派生类的成员函数。（其实这些也可以通过在基类中定义虚函数来实现）
2. 抽象类跟一般类不同的是，它使用纯虚函数，不需要定义纯虚函数的实现。
3. 抽象类不能实例化，即不能定义抽象类的对象，只能从它继承出非抽象派生类再实例化。

纯虚函数

虚函数在基类中不需要做任何工作，我们也要写出一个空的函数体，这时这个函数体没有什么意义，重要的是此虚函数的原型声明。

C++为我们提供了纯虚函数，让我们在这种情况下不用写函数实现，只给出函数原型作为整个类族的统一接口就可以了，函数的实现可以在派生类中给出。纯虚函数是在基类中声明的，声明形式为：

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

• 纯虚函数的声明形式与一般虚函数类似，只是最后加了个"=0"。纯虚函数这样声明以后，在基类中就不再给出它的实现了，各个派生类可以根据自己的功能需要定义其实现。

抽象类

抽象类就是含有纯虚函数的类。抽象类可以为某个类族定义统一的接口，接口的具体实现是在派生类中给出。这种实现就具有多态特性。

• 抽象类的派生类如果没有实现所有的纯虚函数，只给出了部分纯虚函数的实现，那么这个派生类仍然是抽象类，仍然不能实例化，只有给出了全部纯虚函数的实现，派生类才不再是抽象类并且才可以实例化。
• 我们不能声明抽象类的对象，使用抽象类一般是通过声明抽象类的指针或引用，将指针或引用指向派生类的对象，访问派生类的成员。

#include <iostream>
using namespace std;
class Base           // 抽象类Base的声明
{
public:
    virtual void show() = 0;      // 纯虚函数成员show
};
class Child0 : public Base     // 类Base的公有派生类Child0的声明
{
public:
    void show() { cout << "Child0::show()" << endl; }    // 虚成员函数show
};
class Child1 : public Child0   // 类Child0的公有派生类Child1的声明
{
public:
    void show() { cout << "Child1::show()" << endl; }    // 虚成员函数show
};
void CallShow(Base* pBase)     // 一般函数，参数为基类指针
{
    pBase->show();
}
int main()
{
    Base* pBase;             // 声明Base类的指针
    Child0 ch0;                 // 声明Child0类的对象
    Child1 ch1;                 // 声明Child1类的对象
    pBase = &ch0;           // 将Child0类对象ch0的地址赋值给Base类指针pBase
    CallShow(pBase);
    pBase = &ch1;           // 将Child1类对象ch1的地址赋值给Base类指针pBase
    CallShow(pBase);
    return 0;
}

• 这里派生类Child0和Child1的虚函数show并没有使用关键字virtual显式说明，因为Child0和Child1中的虚函数和基类Base中的纯虚函数名称一样，参数和返回值都相同，编译器会自动识别其为虚函数。
• 上面的程序中，基类Base是抽象类，为整个类族提供了统一的外部接口。派生类Child0中给出了全部纯虚函数的实现（其实只有一个纯虚函数--show），因此不再是抽象类，可以声明它的对象。Child0的派生类Child1当然也不是抽象类。根据赋值兼容规则，基类Base的指针可以指向派生类Child0和Child1的对象，通过此指针可以访问派生类的成员，这样就实现了多态。