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

快速回答：

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

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

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

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

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

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

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

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

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

虚拟函数避免了不必要的类型转换问题，我们中的一些人会争论，当我们可以使用派生类指针来调用派生类中特定的函数时，为什么需要虚拟函数！答案是，它否定了在大型系统开发中继承的全部思想，因为在大型系统中，非常需要使用单指针基类对象。

让我们比较以下两个简单的程序，以了解虚拟函数的重要性：

无虚拟功能的程序：

#include <iostream>
using namespace std;

class father
{
    public: void get_age() {cout << "Fathers age is 50 years" << endl;}
};

class son: public father
{
    public : void get_age() { cout << "son`s age is 26 years" << endl;}
};

int main(){
    father *p_father = new father;
    son *p_son = new son;

    p_father->get_age();
    p_father = p_son;
    p_father->get_age();
    p_son->get_age();
    return 0;
}

输出：

Fathers age is 50 years
Fathers age is 50 years
son`s age is 26 years

具有虚拟功能的程序：

#include <iostream>
using namespace std;

class father
{
    public:
        virtual void get_age() {cout << "Fathers age is 50 years" << endl;}
};

class son: public father
{
    public : void get_age() { cout << "son`s age is 26 years" << endl;}
};

int main(){
    father *p_father = new father;
    son *p_son = new son;

    p_father->get_age();
    p_father = p_son;
    p_father->get_age();
    p_son->get_age();
    return 0;
}

输出：

Fathers age is 50 years
son`s age is 26 years
son`s age is 26 years

通过仔细分析这两个输出，可以理解虚拟函数的重要性。

解释了虚拟功能的需求[易于理解]

#include<iostream>

using namespace std;

class A{
public: 
        void show(){
        cout << " Hello from Class A";
    }
};

class B :public A{
public:
     void show(){
        cout << " Hello from Class B";
    }
};


int main(){

    A *a1 = new B; // Create a base class pointer and assign address of derived object.
    a1->show();

}

输出将为：

Hello from Class A.

但具有虚拟功能：

#include<iostream>

using namespace std;

class A{
public:
    virtual void show(){
        cout << " Hello from Class A";
    }
};

class B :public A{
public:
    virtual void show(){
        cout << " Hello from Class B";
    }
};


int main(){

    A *a1 = new B;
    a1->show();

}

输出将为：

Hello from Class B.

因此，使用虚拟函数可以实现运行时多态性。

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

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

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

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++中的早期和后期绑定。

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