虚拟函数用于支持运行时多态性。

也就是说，virtual关键字告诉编译器不要在编译时做出（函数绑定的）决定，而是推迟到运行时”。

您可以通过在函数的基类声明中的关键字virtual之前使其成为虚拟函数。例如类基础{虚虚函数（）；}当基类具有虚拟成员函数时，从基类继承的任何类都可以使用完全相同的原型重新定义该函数，即只能重新定义功能，而不能重新定义函数的接口。类派生：公共基{void函数（）；}基类指针可用于指向基类对象和派生类对象。当使用基类指针调用虚拟函数时，编译器在运行时决定要调用函数的哪个版本（即基类版本或重写的派生类版本）。这被称为运行时多态性。

您需要虚拟方法来实现安全的下变频、简单和简洁。

这就是虚拟方法所做的：它们安全地向下转换，使用明显简单而简洁的代码，避免了在更复杂和冗长的代码中进行不安全的手动转换。

---

Non-virtual method ⇒ static binding ========================================

以下代码故意“不正确”。它没有将value方法声明为virtual，因此会产生意外的“错误”结果，即0:

#include <iostream>
using namespace std;

class Expression
{
public:
    auto value() const
        -> double
    { return 0.0; }         // This should never be invoked, really.
};

class Number
    : public Expression
{
private:
    double  number_;
    
public:
    auto value() const
        -> double
    { return number_; }     // This is OK.

    Number( double const number )
        : Expression()
        , number_( number )
    {}
};

class Sum
    : public Expression
{
private:
    Expression const*   a_;
    Expression const*   b_;
    
public:
    auto value() const
        -> double
    { return a_->value() + b_->value(); }       // Uhm, bad! Very bad!

    Sum( Expression const* const a, Expression const* const b )
        : Expression()
        , a_( a )
        , b_( b )
    {}
};

auto main() -> int
{
    Number const    a( 3.14 );
    Number const    b( 2.72 );
    Number const    c( 1.0 );

    Sum const       sum_ab( &a, &b );
    Sum const       sum( &sum_ab, &c );
    
    cout << sum.value() << endl;
}

在注释为“坏”的行中，调用了Expression:：value方法，因为静态已知类型（编译时已知的类型）是Expression，而value方法不是虚拟的。

---

Virtual method ⇒ dynamic binding. ======================================

在静态已知类型表达式中将值声明为virtual可确保每次调用都会检查这是什么实际类型的对象，并调用该动态类型的值的相关实现：

#include <iostream>
using namespace std;

class Expression
{
public:
    virtual
    auto value() const -> double
        = 0;
};

class Number
    : public Expression
{
private:
    double  number_;
    
public:
    auto value() const -> double
        override
    { return number_; }

    Number( double const number )
        : Expression()
        , number_( number )
    {}
};

class Sum
    : public Expression
{
private:
    Expression const*   a_;
    Expression const*   b_;
    
public:
    auto value() const -> double
        override
    { return a_->value() + b_->value(); }    // Dynamic binding, OK!

    Sum( Expression const* const a, Expression const* const b )
        : Expression()
        , a_( a )
        , b_( b )
    {}
};

auto main() -> int
{
    Number const    a( 3.14 );
    Number const    b( 2.72 );
    Number const    c( 1.0 );

    Sum const       sum_ab( &a, &b );
    Sum const       sum( &sum_ab, &c );
    
    cout << sum.value() << endl;
}

这里的输出应该是6.86，因为虚拟方法是虚拟调用的。这也称为调用的动态绑定。执行一点检查，找到对象的实际动态类型，并调用该动态类型的相关方法实现。

相关的实现是最特定（最派生）类中的实现。

注意，这里的派生类中的方法实现没有标记为virtual，而是标记为override。它们可以被标记为虚拟，但它们是自动虚拟的。override关键字确保如果某个基类中没有这样的虚拟方法，那么您将得到一个错误（这是可取的）。

---

The ugliness of doing this without virtual methods ==================================================

如果没有虚拟绑定，则必须实现一些自己动手版本的动态绑定。这通常涉及不安全的手动降级、复杂性和冗长。

对于单个函数的情况，如这里所示，将函数指针存储在对象中并通过该函数指针进行调用就足够了，但即使如此，它也会涉及一些不安全的下变频、复杂性和冗长性，即：

#include <iostream>
using namespace std;

class Expression
{
protected:
    typedef auto Value_func( Expression const* ) -> double;

    Value_func* value_func_;

public:
    auto value() const
        -> double
    { return value_func_( this ); }
    
    Expression(): value_func_( nullptr ) {}     // Like a pure virtual.
};

class Number
    : public Expression
{
private:
    double  number_;
    
    static
    auto specific_value_func( Expression const* expr )
        -> double
    { return static_cast<Number const*>( expr )->number_; }

public:
    Number( double const number )
        : Expression()
        , number_( number )
    { value_func_ = &Number::specific_value_func; }
};

class Sum
    : public Expression
{
private:
    Expression const*   a_;
    Expression const*   b_;
    
    static
    auto specific_value_func( Expression const* expr )
        -> double
    {
        auto const p_self  = static_cast<Sum const*>( expr );
        return p_self->a_->value() + p_self->b_->value();
    }

public:
    Sum( Expression const* const a, Expression const* const b )
        : Expression()
        , a_( a )
        , b_( b )
    { value_func_ = &Sum::specific_value_func; }
};


auto main() -> int
{
    Number const    a( 3.14 );
    Number const    b( 2.72 );
    Number const    c( 1.0 );

    Sum const       sum_ab( &a, &b );
    Sum const       sum( &sum_ab, &c );
    
    cout << sum.value() << endl;
}

看待这一点的一种积极方式是，如果您遇到了如上所述的不安全的下变频、复杂性和冗长，那么通常一个或多个虚拟方法确实会有帮助。

我想添加虚拟函数的另一种用法，尽管它使用了与上述答案相同的概念，但我认为它值得一提。

虚拟析构函数

考虑下面的这个程序，不要将基类析构函数声明为virtual；Cat的内存可能无法清理。

class Animal {
    public:
    ~Animal() {
        cout << "Deleting an Animal" << endl;
    }
};
class Cat:public Animal {
    public:
    ~Cat() {
        cout << "Deleting an Animal name Cat" << endl;
    }
};

int main() {
    Animal *a = new Cat();
    delete a;
    return 0;
}

输出：

删除动物

class Animal {
    public:
    virtual ~Animal() {
        cout << "Deleting an Animal" << endl;
    }
};
class Cat:public Animal {
    public:
    ~Cat(){
        cout << "Deleting an Animal name Cat" << endl;
    }
};

int main() {
    Animal *a = new Cat();
    delete a;
    return 0;
}

输出：

删除动物名称猫删除动物

你熟悉函数指针吗？虚拟函数也是一个类似的想法，只是您可以轻松地将数据绑定到虚拟函数（作为类成员）。将数据绑定到函数指针并不容易。对我来说，这是主要的概念区别。这里的许多其他答案只是说“因为…多态性！”

我们需要支持“运行时多态性”的虚拟方法。当使用指针或对基类的引用引用派生类对象时，可以为该对象调用虚拟函数并执行派生类版本的函数。

如果基类是base，派生类是Der，则可以有一个base*p指针，它实际上指向Der的实例。当您调用p->foo（）；时；，如果foo不是虚拟的，则执行Base版本的foo，忽略p实际上指向Der的事实。如果foo是虚拟的，则p->foo（）执行foo的“最叶”覆盖，充分考虑指向项的实际类。因此，虚拟和非虚拟之间的区别实际上非常关键：前者允许运行时多态性，这是OO编程的核心概念，而后者则不允许。