下面是前两个答案的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对象相同。

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

#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;
}

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

假设您有以下两个类：

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

完成。

关于效率，虚拟函数的效率略低于早期绑定函数。

“这种虚拟调用机制的效率几乎可以与“正常函数调用”机制一样高（25%以内）。它的空间开销是一个具有虚拟函数的类的每个对象中的一个指针加上每个此类类的一个vtbl”[Bjarne Stroustrup的C++教程]

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

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

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

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

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

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

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

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