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

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

假设您有以下两个类：

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

完成。

如果没有“虚拟”，您将获得“早期绑定”。在编译时，根据您调用的指针的类型来决定使用该方法的哪个实现。

使用“虚拟”，您将获得“后期绑定”。使用方法的哪种实现在运行时根据指向对象的类型来决定，即它最初的构造形式。这不一定是根据指向该对象的指针的类型来考虑的。

class Base
{
  public:
            void Method1 ()  {  std::cout << "Base::Method1" << std::endl;  }
    virtual void Method2 ()  {  std::cout << "Base::Method2" << std::endl;  }
};

class Derived : public Base
{
  public:
    void Method1 ()  {  std::cout << "Derived::Method1" << std::endl;  }
    void Method2 ()  {  std::cout << "Derived::Method2" << std::endl;  }
};

Base* basePtr = new Derived ();
  //  Note - constructed as Derived, but pointer stored as Base*

basePtr->Method1 ();  //  Prints "Base::Method1"
basePtr->Method2 ();  //  Prints "Derived::Method2"

编辑-请参阅此问题。

此外，本教程还介绍了C++中的早期和后期绑定。

下面是一个完整的示例，说明了为什么使用虚拟方法。

#include <iostream>

using namespace std;

class Basic
{
    public:
    virtual void Test1()
    {
        cout << "Test1 from Basic." << endl;
    }
    virtual ~Basic(){};
};
class VariantA : public Basic
{
    public:
    void Test1()
    {
        cout << "Test1 from VariantA." << endl;
    }
};
class VariantB : public Basic
{
    public:
    void Test1()
    {
        cout << "Test1 from VariantB." << endl;
    }
};

int main()
{
    Basic *object;
    VariantA *vobjectA = new VariantA();
    VariantB *vobjectB = new VariantB();

    object=(Basic *) vobjectA;
    object->Test1();

    object=(Basic *) vobjectB;
    object->Test1();

    delete vobjectA;
    delete vobjectB;
    return 0;
}

对虚拟函数的解释存在的问题是，它们没有解释如何在实践中使用它，以及它如何有助于维护。我创建了一个虚拟函数教程，人们已经发现它非常有用。此外，它基于战场前提，这让它更令人兴奋：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的代码。

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

---

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

因为多态性。

什么是多态性？

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

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

嗯，通过早期绑定。

什么是早期绑定？

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();

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