virtual关键字强制编译器选择对象类中定义的方法实现，而不是指针类中的方法实现。

Shape *shape = new Triangle(); 
cout << shape->getName();

在上面的示例中，默认情况下将调用Shape:：getName，除非getName（）在基类Shape中定义为virtual。这迫使编译器在Triangle类而不是Shape类中查找getName（）实现。

虚拟表是编译器跟踪子类的各种虚拟方法实现的机制。这也被称为动态调度，并且存在一些与之相关的开销。

最后，为什么在C++中甚至需要虚拟，为什么不将其作为Java中的默认行为？

C++基于“零开销”和“按需付费”的原则。因此，除非您需要，否则它不会尝试为您执行动态调度。为界面提供更多控制。通过使函数非虚拟化，接口/抽象类可以控制其所有实现中的行为。

下面是前两个答案的C++代码的合并版本。

#include        <iostream>
#include        <string>

using   namespace       std;

class   Animal
{
        public:
#ifdef  VIRTUAL
                virtual string  says()  {       return  "??";   }
#else
                string  says()  {       return  "??";   }
#endif
};

class   Dog:    public Animal
{
        public:
                string  says()  {       return  "woof"; }
};

string  func(Animal *a)
{
        return  a->says();
}

int     main()
{
        Animal  *a = new Animal();
        Dog     *d = new Dog();
        Animal  *ad = d;

        cout << "Animal a says\t\t" << a->says() << endl;
        cout << "Dog d says\t\t" << d->says() << endl;
        cout << "Animal dog ad says\t" << ad->says() << endl;

        cout << "func(a) :\t\t" <<      func(a) <<      endl;
        cout << "func(d) :\t\t" <<      func(d) <<      endl;
        cout << "func(ad):\t\t" <<      func(ad)<<      endl;
}

两种不同的结果是：

如果没有#define virtual，它将在编译时绑定。Animal*ad和func（Animal*）都指向Animal的says（）方法。

$ g++ virtual.cpp -o virtual
$ ./virtual 
Animal a says       ??
Dog d says      woof
Animal dog ad says  ??
func(a) :       ??
func(d) :       ??
func(ad):       ??

使用#define virtual，它在运行时绑定。Dog*d、Animal*ad和func（Animal*）指向/引用Dog的says（）方法，因为Dog是它们的对象类型。除非未定义[Dog's says（）“woof”]方法，否则它将是在类树中首先搜索的方法，即派生类可能会覆盖其基类的方法[Eanimal's says）]。

$ g++ virtual.cpp -D VIRTUAL -o virtual
$ ./virtual 
Animal a says       ??
Dog d says      woof
Animal dog ad says  woof
func(a) :       ??
func(d) :       woof
func(ad):       woof

有趣的是，Python中的所有类属性（数据和方法）都是虚拟的。由于所有对象都是在运行时动态创建的，因此不需要类型声明或关键字virtual。下面是Python的代码版本：

class   Animal:
        def     says(self):
                return  "??"

class   Dog(Animal):
        def     says(self):
                return  "woof"

def     func(a):
        return  a.says()

if      __name__ == "__main__":

        a = Animal()
        d = Dog()
        ad = d  #       dynamic typing by assignment

        print("Animal a says\t\t{}".format(a.says()))
        print("Dog d says\t\t{}".format(d.says()))
        print("Animal dog ad says\t{}".format(ad.says()))

        print("func(a) :\t\t{}".format(func(a)))
        print("func(d) :\t\t{}".format(func(d)))
        print("func(ad):\t\t{}".format(func(ad)))

输出为：

Animal a says       ??
Dog d says      woof
Animal dog ad says  woof
func(a) :       ??
func(d) :       woof
func(ad):       woof

这与C++的虚拟定义相同。注意，d和ad是两个不同的指针变量，引用/指向同一个Dog实例。表达式（ad is d）返回True，其值与0xb79f72cc>处的<main.Dog对象相同。

您需要至少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
}

为什么我们需要C++中的虚拟方法？

快速回答：

它为我们提供了面向对象编程所需的“要素”之一。

在Bjarne Stroustrup C++编程：原理与实践中，（14.3）：

虚拟函数提供了在基类中定义函数的能力，并在用户调用基类函数时在派生类中具有相同名称和类型的函数。这通常称为运行时多态性、动态调度或运行时调度，因为调用的函数是在运行时根据所使用的对象类型确定的。

如果您需要虚拟函数调用2，这是最快、更有效的实现。

为了处理虚拟调用，需要一条或多条与派生对象3相关的数据。通常的做法是添加函数表的地址。该表通常称为虚拟表或虚拟函数表，其地址通常称为虚指针。每个虚拟函数在虚拟表中都有一个槽。根据调用者的对象（派生）类型，虚拟函数依次调用相应的重写。

1.使用继承、运行时多态性和封装是面向对象编程的最常见定义。

2.您不能在运行时使用其他语言功能在备选方案中进行选择，从而使功能更快或使用更少的内存。Bjarne Stroustrup C++编程：原理与实践。(14.3.1).

3.当我们调用包含虚拟函数的基类时，可以判断哪个函数真正被调用。

跟进@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

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

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

细节：

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

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

假设您有以下两个类：

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

完成。