以下是我如何理解虚拟函数的含义，以及为什么需要它们：

假设您有以下两个类：

class Animal
{
    public:
        void eat() { std::cout << "I'm eating generic food."; }
};

class Cat : public Animal
{
    public:
        void eat() { std::cout << "I'm eating a rat."; }
};

在主功能中：

Animal *animal = new Animal;
Cat *cat = new Cat;

animal->eat(); // Outputs: "I'm eating generic food."
cat->eat();    // Outputs: "I'm eating a rat."

到目前为止还不错，对吧？动物吃普通食物，猫吃老鼠，都没有虚拟食物。

现在让我们稍微改变一下，以便通过一个中间函数调用eat（）（本例中的一个普通函数）：

// This can go at the top of the main.cpp file
void func(Animal *xyz) { xyz->eat(); }

现在我们的主要功能是：

Animal *animal = new Animal;
Cat *cat = new Cat;

func(animal); // Outputs: "I'm eating generic food."
func(cat);    // Outputs: "I'm eating generic food."

哦哦。。。我们把一只猫传给func（），但它不会吃老鼠。是否应该重载func（）以使其使用Cat*？如果你必须从Animal派生出更多的动物，它们都需要自己的func（）。

解决方案是使Animal类中的eat（）成为一个虚拟函数：

class Animal
{
    public:
        virtual void eat() { std::cout << "I'm eating generic food."; }
};

class Cat : public Animal
{
    public:
        void eat() { std::cout << "I'm eating a rat."; }
};

主要内容：

func(animal); // Outputs: "I'm eating generic food."
func(cat);    // Outputs: "I'm eating a rat."

完成。

我以对话的形式给出了答案，以便更好地阅读：

---

为什么我们需要虚拟功能？

因为多态性。

什么是多态性？

基指针也可以指向派生类型对象。

多态性的定义是如何导致对虚拟函数的需求的？

嗯，通过早期绑定。

什么是早期绑定？

C++中的早期绑定（编译时绑定）意味着在执行程序之前，函数调用是固定的。

所以

因此，如果您使用基类型作为函数的参数，编译器将只识别基接口，如果您用派生类的任何参数调用该函数，它将被截断，这不是您想要的。

如果这不是我们想要的，为什么允许这样做？

因为我们需要多态性！

那么多态性的好处是什么？

您可以使用基类型指针作为单个函数的参数，然后在程序运行时，您可以使用该基指针的解引用来访问每个派生类型接口（例如，它们的成员函数），而不会出现任何问题。

我仍然不知道虚拟函数有什么好处。。。！这是我的第一个问题！

嗯，这是因为你问得太快了！

为什么我们需要虚拟功能？

假设您使用基指针调用了一个函数，该函数具有来自其派生类之一的对象地址。正如我们上面所讨论的，在运行时，这个指针会被取消引用，但是，到目前为止，我们希望“从我们的派生类”执行一个方法（==成员函数）！然而，基类中已经定义了相同的方法（具有相同标头的方法），那么为什么您的程序要费心选择另一个方法呢？换言之，我的意思是，你怎么能把这种情况与我们以前通常看到的情况区分开来？

简单的答案是“基类中的一个虚拟成员函数”，稍长一点的答案是，“在这一步，如果程序在基类中看到一个虚拟函数，它知道（意识到）您正在尝试使用多态性”，因此去到派生类（使用v-table，一种后期绑定形式），发现另一个方法具有相同的头，但预期实现不同。

为什么实施不同？

你这个笨蛋！去读一本好书吧！

好吧，等等，等等，当他/她可以简单地使用派生类型指针时，为什么还要麻烦使用基指针呢？你是法官，所有这些头疼值得吗？看看这两个片段：

//1:

Parent* p1 = &boy;
p1 -> task();
Parent* p2 = &girl;
p2 -> task();

//2:

Boy* p1 = &boy;
p1 -> task();
Girl* p2 = &girl;
p2 -> task();

好吧，虽然我认为1还是比2好，但你也可以这样写1：

//1:

Parent* p1 = &boy;
p1 -> task();
p1 = &girl;
p1 -> task();

此外，你应该意识到，这只是我迄今为止向你解释的所有事情的一种人为使用。相反，假设例如在程序中有一个函数分别使用每个派生类的方法（getMonthBenefit（））：

double totalMonthBenefit = 0;    
std::vector<CentralShop*> mainShop = { &shop1, &shop2, &shop3, &shop4, &shop5, &shop6};
for(CentralShop* x : mainShop){
     totalMonthBenefit += x -> getMonthBenefit();
}

现在，试着重新写一遍，不要让人头疼！

double totalMonthBenefit=0;
Shop1* branch1 = &shop1;
Shop2* branch2 = &shop2;
Shop3* branch3 = &shop3;
Shop4* branch4 = &shop4;
Shop5* branch5 = &shop5;
Shop6* branch6 = &shop6;
totalMonthBenefit += branch1 -> getMonthBenefit();
totalMonthBenefit += branch2 -> getMonthBenefit();
totalMonthBenefit += branch3 -> getMonthBenefit();
totalMonthBenefit += branch4 -> getMonthBenefit();
totalMonthBenefit += branch5 -> getMonthBenefit();
totalMonthBenefit += branch6 -> getMonthBenefit();

事实上，这可能也是一个虚构的例子！

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

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

---

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关键字，则只能重载基类的方法。这只意味着隐藏。假设您有一个基类base和一个派生类Specialized，它们都实现了void foo（）。现在有一个指向Base的指针指向Specialized的实例。当您对其调用foo（）时，您可以观察到virtual的不同之处：如果该方法是虚拟的，则将使用Specialized的实现，如果缺少，则将选择Base的版本。最好不要重载基类中的方法。使方法非虚拟化是作者告诉你它在子类中的扩展不是有意的。

关键字virtual告诉编译器它不应该执行早期绑定。相反，它应该自动安装执行后期绑定所需的所有机制。为了实现这一点，典型的编译器1为每个包含虚拟函数的类创建一个表（称为VTABLE）。编译器将该特定类的虚拟函数的地址放在VTABLE中。在每个具有虚拟函数的类中，它都会秘密地放置一个指针，称为vpointer（缩写为VPTR），该指针指向该对象的VTABLE。当您通过基类指针进行虚拟函数调用时，编译器会悄悄地插入代码以获取VPTR并在VTABLE中查找函数地址，从而调用正确的函数并导致延迟绑定。

此链接中的详细信息http://cplusplusinterviews.blogspot.sg/2015/04/virtual-mechanism.html

我认为您所指的是这样一个事实：一旦方法被声明为virtual，您就不需要在重写中使用“virtual”关键字。

class Base { virtual void foo(); };

class Derived : Base 
{ 
  void foo(); // this is overriding Base::foo
};

如果在Base的foo声明中不使用“virtual”，那么Derived的foo将只是隐藏它。