【C++】C++中的虚函数与纯虚函数

C++中的虚函数

　　先来看一下实际的场景，就很容易明白为什么要引入虚函数的概念。假设我们有一个基类Base，Base中有一个方法eat；有一个派生类Derived从基类继承来，并且覆盖(Override)了基类的eat；继承表明ISA（“是一个”）的关系，现在我们有一个基类的指针（引用）绑定到派生类对象（因为派生类对象是基类的一个特例，我们当然可以用基类指针指向派生类对象），当我们调用pBase->eat()的时候，我们希望调用的是Derived类的eat，而实际上调用的是Base类的eat，测试代码如下：

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class Base
{
public:
    Base(){}

    void eat()
    {
        cout << "I am base eat()" << endl;
    }
private:

};

class Derived:public Base
{
public:
    Derived(){}

    void eat()
    {
        cout << "I am derived eat()" << endl;
    }
};

int main()
{
    Base* pBase;
    Base base;
    Derived* pDerived;
    Derived derived;

    // 如果基类声明为普通函数,基类指针不管指向基类对象还是派生类对象，基类指针都调用基类函数
    pBase = &derived;
    pBase->eat();
    pBase = &base;
    pBase->eat();


    return 0;
}

　　运行结果如下：

　　我们将基类指针分别绑定到派生类对象和基类对象，运行结果显示我们始终调用的是基类的函数，这个时候调用哪个函数是由指针的静态类型决定的，因为pBase为Base的指针，所以不管指向基类对象还是派生类对象，都会调用由指针静态类型所决定的函数。

      为了能够实现，当基类指针指向派生类对象的时候，自动调用派生类对象自己实现的函数，C++引入了虚函数的概念。可以声明基类函数为虚函数，派生类对象覆盖了整个虚函数之后，根据派生类对象的类别自动调用派生类自己实现的函数。还是上面的例子，这次我们将基类的eat函数声明为虚函数(virtual)

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class Base
{
public:
    Base(){}

    // 基类声明为虚函数
    virtual void eat()
    {
        cout << "I am base eat()" << endl;
    }
private:

};

class Derived:public Base
{
public:
    Derived(){}

    void eat()
    {
        cout << "I am derived eat()" << endl;
    }
};

int main()
{
    Base* pBase;
    Base base;
    Derived* pDerived;
    Derived derived;

    // 基类指针指向派生类时，调用派生类的eat函数；指向基类时调用基类的eat函数
    pBase = &derived;
    pBase->eat();
    pBase = &base;
    pBase->eat();


    return 0;
}

  　　运行结果如下：

 　　从运行结果可以看到，基类指针在绑定基类对象时调用了基类的eat函数，在绑定派生类对象时调用了派生类的eat函数，具体调用哪个函数是运行时决定的。

      小结：如果没有虚函数，无论基类指针指向的实际对象是什么，都会调用基类定义的函数，无法实现多态行为。为了实现多态行为，C++引入了虚函数。具体的方式是在基类（需要实现多态）的成员函数声明之前加上virtual关键字，派生类对象覆盖override该虚函数，然后将基类的指针（或者引用）的指针绑定到派生类对象或基类对象上，编译器在运行时确定指针所指向的具体对象，并自动调用具体对象的成员函数。

纯虚函数

    前面讨论了我们C++通过引入虚函数来实现多态的特性。然而有时会出现这样的场景，基类的某些虚函数对于基类本身是没有意义的，它只是为了让派生类去继承这个函数并override自己的实现。比如：我们有一个平面图形Figure类，所有的平面图像都有面积Area函数来计算平面图形的面积，然而直接定义一个Figure对象却没有指明具体的类别，并且去调用Area函数是没有意义的。我们并不希望用户这样做，但是在仅仅引入虚函数的情况下，我们却没有办法避免用户这么做。代码实例如下：

#include <iostream>
using namespace std;

class Figure
{
public:
    Figure(){}
    virtual double Area()
    {
        return 0.0;
    }
};

class Rect:public Figure
{
public:
    Rect(double w = 10.0, double h = 10.0):Figure(), width_(w), height_(h){}
    double Area()
    {
        return width_ * height_;
    }
private:
    double width_;
    double height_;
};

class Circle:public Figure
{
public:
    Circle(double r = 10.0):Figure(), radius_(r){}
    double Area()
    {
        return 3.14 * radius_ * radius_;
    }
private:
    double radius_;
};

int main()
{
    // 这样的定义和调用并没有任何意义
    // 我们并不清楚用户这样做要达到什么的行为，我们宁愿用户根本不能定义Figure类
    Figure figure;
    figure.Area();
    
    return 0;
}

     为了避免用户定义Figure类并调用Area函数，C++引入了纯虚函数概念， 通过将Area函数声明为纯虚函数(pure virtual function)，来避免创建Figure类对象，纯虚函数的声明是在虚函数后面加上=0，代码如下：

#include <iostream>
using namespace std;

class Figure
{
public:
    Figure(){}
    
    // 声明Area函数为纯虚函数
    virtual double Area() = 0;
};

class Rect:public Figure
{
public:
    Rect(double w = 10.0, double h = 10.0):Figure(), width_(w), height_(h){}
    double Area()
    {
        cout << "Rect Area: " << width_ * height_ << endl;
        return width_ * height_;
    }
private:
    double width_;
    double height_;
};

class Circle:public Figure
{
public:
    Circle(double r = 10.0):Figure(), radius_(r){}
    double Area()
    {
        cout << "Circle Area: " << 3.14 * radius_ * radius_ << endl;
        return 3.14 * radius_ * radius_;
    }
private:
    double radius_;
};

int main()
{
    // 创建包含纯虚函数的类对象会出现编译错误
    // Figure figure;
    // figure.Area();

    // 再来体会一下多态特性
    Figure* pFigure;
    Rect rect;
    Circle circle;
    pFigure = &rect;
    pFigure->Area();
    pFigure = &circle;
    pFigure->Area();
    
    return 0;
}

　　运行结果如下：

     

      如果定义Figure类对象figure会出现编译错误，编译显示不能定义抽象类实例对象。C++将包含一个或者多个虚函数的类称为抽象类，用户不能定义抽象类的具体对象，派生类必须override其继承的每一个纯虚函数，否则派生类也为抽象类，不能直接使用。注意纯虚函数通常情况下只有声明，并没有定义，留作派生类override。但是纯虚函数有定义也是可以的，表明基类希望派生类继承某些共性行为。

C++虚函数与纯虚函数总结如下：

【1】C++通过引入虚函数来实现多态行为。虚函数的声明方式如下：  virtual returnType FunctionName(Parameters List) ，派生类可以override基类的虚函数实现自己的行为，当基类指针或引用绑定到派生类对象时，在运行时确定指针指向的对象具体类型，并自动调用相应类型的函数实现多态行为。

【2】析构函数应该是虚函数，这是因为假设虚构函数不是虚函数，如果基类指针指向派生类对象，如果没有虚函数提供多态机制，那么基类指针只是调用基类对应的析构函数，并没有析构派生类对象的派生类部分，因而出现资源并没有完全释放的情况；反之，如果基类的虚构函数是虚函数，则基类指针多态的调用派生类的析构函数，最后调用基类的析构函数，从而完成完全的析构过程。

【2】C++引入纯虚函数来规范派生类的行为，实际上等同于告诉派生类 “你必须提供这些纯虚函数的具体实现，我并不关心你具体是怎么实现的”。纯虚函数的声明方式如下： virtual returnType FunctionName(Parameter List) = 0; 。

【3】定义了一个以上纯虚函数的类称为抽象类，抽象类不能定义具体的实例对象，但是可以定义抽象类的指针或引用。抽象类的派生类必须override其继承的所有纯虚函数，否则派生类也成为抽象类，不能直接使用。在具体的工程实践过程中，抽象类一般指生命纯虚函数，但是并不定义纯虚函数，而是由其派生类来override这些纯虚函数，这样做到了派生类只是继承了抽象类的接口，但是并不继承抽象类的实现（因为根本就没有实现）。

 参考文献

[1] Wiki:Virtual function

[2] Hackbuteer1的专栏：虚函数与纯虚函数的区别

[3] 类别（class）继承的一些特性