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

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

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

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

class Base { virtual void foo(); };

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

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

跟进@user6359267的回答，C++范围层次结构是

global -> namespace -> class -> local -> statement

因此，每个类都定义了一个范围。如果不是这样的话，子类中的重写函数实际上会在同一范围内重新定义函数，而链接器不允许这样做：

在每个翻译单元中使用之前必须声明函数，并且一个函数只能在整个程序（跨所有翻译单元）的给定范围内定义一次

由于每个类都定义了自己的作用域，因此被调用的函数是在调用该函数的对象的类中定义的函数。所以

#include <iostream>
#include <string>

class Parent
{
public:
    std::string GetName() { return "Parent"; }
};

class Child : public Parent
{
public:
    std:::string GetName() { return "Child"; }
};

int main()
{
    Parent* parent = new Parent();
    std::cout << parent->GetName() << std::endl;

    Child* child = new Child();
    std::cout << child->GetName() << std::endl;

    *parent = child;
    std::cout << child->GetName() << std::endl;

    return 0;
}

输出

Parent
Child
Parent

因此，我们需要一种方法来告诉编译器应该在运行时而不是编译时确定要调用的函数。这就是虚拟关键字的作用。

这就是为什么函数重载被称为编译时多态（或早期绑定），而虚拟函数重写被称为运行时多态（或者后期绑定）。

细节：

在内部，当编译器看到一个虚拟函数时，它会创建一个类成员指针，该指针使用.*和->*运算符一般指向该类的成员（而不是对象中该成员的特定实例）。他们的工作是允许您访问一个类的成员，该成员具有指向该成员的指针。这些很少被程序员直接使用（也许除非你正在编写一个编译器来实现“虚拟”）。

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

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

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