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

假设您有以下两个类：

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."

完成。

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

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

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

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

接口设计采用虚拟方法。例如，在Windows中有一个名为IUnknown的界面，如下所示：

interface IUnknown {
  virtual HRESULT QueryInterface (REFIID riid, void **ppvObject) = 0;
  virtual ULONG   AddRef () = 0;
  virtual ULONG   Release () = 0;
};

这些方法留给界面用户来实现。它们对于创建和销毁必须继承IUnknown的某些对象至关重要。在这种情况下，运行时知道这三个方法，并期望在调用它们时实现它们。所以在某种意义上，它们充当了对象本身和使用该对象的任何事物之间的契约。

您需要至少1个级别的继承和一个升级来演示它。下面是一个非常简单的示例：

class Animal
{        
    public: 
      // turn the following virtual modifier on/off to see what happens
      //virtual   
      std::string Says() { return "?"; }  
};

class Dog: public Animal
{
    public: std::string Says() { return "Woof"; }
};

void test()
{
    Dog* d = new Dog();
    Animal* a = d;       // refer to Dog instance with Animal pointer

    std::cout << d->Says();   // always Woof
    std::cout << a->Says();   // Woof or ?, depends on virtual
}

对虚拟函数的解释存在的问题是，它们没有解释如何在实践中使用它，以及它如何有助于维护。我创建了一个虚拟函数教程，人们已经发现它非常有用。此外，它基于战场前提，这让它更令人兴奋：https://nrecursions.blogspot.com/2015/06/so-why-do-we-need-virtual-functions.html.

考虑这个战场应用：

#include "iostream"

//This class is created by Gun1's company
class Gun1 {public: void fire() {std::cout<<"gun1 firing now\n";}};
//This class is created by Gun2's company
class Gun2 {public: void shoot() {std::cout<<"gun2 shooting now\n";}};

//We create an abstract class to interface with WeaponController
class WeaponsInterface {
 public:
 virtual void shootTarget() = 0;
};

//A wrapper class to encapsulate Gun1's shooting function
class WeaponGun1 : public WeaponsInterface {
 private:
 Gun1* g;

 public:
 WeaponGun1(): g(new Gun1()) {}
 ~WeaponGun1() { delete g;}
 virtual void shootTarget() { g->fire(); }
};

//A wrapper class to encapsulate Gun2's shooting function
class WeaponGun2 : public WeaponsInterface {
 private:
 Gun2* g;

 public:
 WeaponGun2(): g(new Gun2()) {}
 ~WeaponGun2() { delete g;}
 virtual void shootTarget() { g->shoot(); }
};

class WeaponController {
 private:
 WeaponsInterface* w;
 WeaponGun1* g1;
 WeaponGun2* g2;
 public:
 WeaponController() {g1 = new WeaponGun1(); g2 = new WeaponGun2(); w = g1;}
 ~WeaponController() {delete g1; delete g2;}
 void shootTarget() { w->shootTarget();}
 void changeGunTo(int gunNumber) {//Virtual functions makes it easy to change guns dynamically
   switch(gunNumber) {
     case 1: w = g1; break;
     case 2: w = g2; break;
   }
 }
};


class BattlefieldSoftware {
 private:
 WeaponController* wc;
 public:
 BattlefieldSoftware() : wc(new WeaponController()) {}
 ~BattlefieldSoftware() { delete wc; }

 void shootTarget() { wc->shootTarget(); }
 void changeGunTo(int gunNumber) {wc->changeGunTo(gunNumber); }
};


int main() {
 BattlefieldSoftware* bf = new BattlefieldSoftware();
 bf->shootTarget();
 for(int i = 2; i > 0; i--) {
     bf->changeGunTo(i);
     bf->shootTarget();
 }
 delete bf;
}

我鼓励您首先阅读博客上的文章，了解包装器类创建的原因。

如图所示，有各种火炮/导弹可以连接到战场软件，并且可以向这些武器发出命令，以进行射击或重新校准等。这里的挑战是能够在不必更改蓝色战场软件的情况下更改/更换火炮/导弹，并且能够在运行时切换武器，而无需更改代码并重新编译。

上面的代码显示了问题是如何解决的，以及具有精心设计的包装类的虚拟函数如何封装函数并帮助在运行时分配派生类指针。WeaponGun1类的创建确保了你将Gun1的处理完全分离到类中。无论你对Gun1做了什么改变，你只需要在WeaponGun1中做出改变，并有信心其他职业不会受到影响。

由于WeaponsInterface类，您现在可以将任何派生类分配给基类指针WeaponsIterface，并且因为它的函数是虚拟的，所以当您调用WeaponsIInterface的shootTarget时，派生类shootTarget将被调用。

最好的部分是，您可以在运行时更改枪（w=g1和w=g2）。这是虚拟函数的主要优势，这也是我们需要虚拟函数的原因。

因此，在更换枪支时，不再需要在不同的地方注释代码。现在，这是一个简单而干净的过程，添加更多的枪类也更容易，因为我们只需要创建一个新的WeaponGun3或WeaponGun 4类，我们可以确信它不会破坏BattlefieldSoftware的代码或WeaponGun1/WeaponGun2的代码。