为什么我们需要C ++中的虚函数？

Question

我正在学习C ++而我正在进入虚拟功能。

根据我的阅读（在书中和在线），虚函数是基类中的函数，您可以在派生类中重写它们。

但是在本书前面，当学习基本继承时，我能够在不使用virtual的情况下覆盖派生类中的基函数。

那我在这里错过了什么？我知道虚拟功能还有更多功能，而且它似乎很重要，所以我想清楚它究竟是什么。我在网上找不到直接答案。

Answer 1

以下是我不仅理解virtual功能的原因，而且还了解为什么需要它们：

假设你有这两个类：

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

到目前为止一切都那么好吧？动物吃普通食物，猫吃老鼠，都没有virtual。

让我们稍微改变它，以便通过中间函数调用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*？如果你必须从动物中获得更多的动物，他们都需要自己的func()。

解决方案是使eat()类的Animal成为虚函数：

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

完成。

Answer 2

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

快速回答：

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

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

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

如果您需要虚拟函数调用2，它是最快速的实现。

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

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

2.您无法使功能更快或使用其他语言功能使用更少的内存来在运行时选择其他选项。 Bjarne Stroustrup C ++编程：原理与实践。（14.3.1）。

3.当我们调用包含虚函数的基类时，要告诉哪个函数真正被调用。

Answer 3

当你在基类中有一个函数时，你可以在派生类中使用Redefine或Override。

重新定义方法：派生类中给出了基类方法的新实现。不利于Dynamic binding。

覆盖方法：Redefining派生类中基类的virtual method。虚方法有助于动态绑定。

所以当你说：

但是在本书前面，当学习基本继承时，我能够在不使用“虚拟”的情况下覆盖派生类中的基本方法。

你没有覆盖它，因为基类中的方法不是虚拟的，而是你重新定义它

Answer 4

我的回答形式是一个更好的阅读：

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

因为多态性。

什么是多态？

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

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

好吧，通过早期绑定。

什么是早期绑定？

C ++中的早期绑定（编译时绑定）意味着在执行程序之前修复了函数调用。

所以...？

因此，如果使用基类型作为函数的参数，编译器将只识别基接口，如果使用派生类中的任何参数调用该函数，它将被切掉，这不是您想要发生的。

如果不是我们想要发生的事情，为什么允许这样做？

因为我们需要多态性！

那么多态性有什么好处呢？

您可以使用基类型指针作为单个函数的参数，然后在程序的运行时，您可以使用该单个的解除引用来访问每个派生类型接口（例如其成员函数）而不会出现任何问题基指针。

我还是不知道虚拟功能对...有什么好处！这是我的第一个问题！

好吧，这是因为你太快问了你的问题！

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

假设您使用基指针调用了一个函数，该指针具有来自其派生类之一的对象的地址。正如我们上面所讨论的那样，在运行时，这个指针被解除引用，到目前为止一直很好，但是，我们期望一个方法（==一个成员函数）“从我们的派生类”执行！但是，在基类中已经定义了相同的方法（具有相同标题的方法），那么为什么您的程序还要选择其他方法呢？换句话说，我的意思是，你怎么能告诉我们以前通常发生的事情呢？

简短的回答是“基础中的虚拟成员函数”，并且更长的答案是，“在此步骤，如果程序在基类中看到虚函数，它知道（实现）您正在尝试使用“多态性”以及派生类（使用v-table，一种后期绑定形式）来查找具有相同标头的另一种方法，但具有 - 预期 - 不同的实现。

为什么不同的实施？

你指关节！去读一个good book！

好的，等待等待，当他/她可以简单地使用派生类型指针时，为什么还要费心去使用基指针呢？你是判断者，这一切都值得吗？看看这两个片段：

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

实际上，这可能是一个人为的例子！

Answer 5

如果你知道底层机制，它会有所帮助。 C ++规范了C程序员使用的一些编码技术，使用“覆盖”替换“类” - 具有公共头部分的结构将用于处理不同类型但具有一些共同数据或操作的对象。通常，覆盖的基础结构（公共部分）具有指向功能表的指针，该功能表指向每种对象类型的不同例程集。 C ++做了同样的事情，但隐藏了机制，即C ++ ptr->func(...)，其中func是虚拟的，因为C将是(*ptr->func_table[func_num])(ptr,...)，其中派生类之间的变化是func_table内容。 [非虚方法ptr-> func（）只是转换为mangled_func（ptr，..）。

结果就是你只需要理解基类就可以调用派生类的方法，即如果例程理解了类A，你可以传递一个派生类B指针，然后调用的虚方法就是那些因为你通过功能表B指向B而不是A.

Answer 6

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

更多细节在这个链接http://cplusplusinterviews.blogspot.sg/2015/04/virtual-mechanism.html

Answer 7

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

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

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

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

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

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

Answer 8

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

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

让我们在下面比较两个简单的程序来理解虚函数的重要性：

没有虚函数的程序：

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

OUTPUT：

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

OUTPUT：

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

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

Answer 9

关于效率，虚拟功能与早期绑定功能相比效率稍低。

“这个虚拟调用机制几乎和”普通函数调用“机制一样有效（在25％以内）。它的空间开销是一个具有虚函数的类的每个对象中的一个指针加上每个这样的类的一个vtbl”[A Bjarne Stroustrup的C ++之旅]

Answer 10

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

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

这些方法留给接口用户实现。它们对于必须继承IUnknown的某些对象的创建和销毁至关重要。在这种情况下，运行时知道这三种方法，并期望在调用它们时实现它们。因此，在某种意义上，它们充当对象本身与对象之间的契约。

Answer 11

这是完整的示例，说明了使用虚方法的原因。

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

Answer 12

没有“虚拟”，你就会得到“早期约束”。根据您调用的指针类型，在编译时决定使用该方法的哪个实现。

使用“虚拟”，您将获得“后期绑定”。使用该方法的哪个实现在运行时根据指向对象的类型决定 - 它最初构造为什么。根据指向该对象的指针类型，这不一定是您的想法。

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* obj = new Derived ();
  //  Note - constructed as Derived, but pointer stored as Base*

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

编辑 - 见this question。

另外 - this tutorial涵盖了C ++中的早期和晚期绑定。

Answer 13

OOP Answer: Subtype Polymorphism

在C ++中，如果从wikipedia应用定义，则需要虚拟方法来实现多态，更准确地说是子类型或子类型多态。

Wikipedia，Subtyping，2019-01-09：在编程语言理论中，子类型（也是子类型多态或包含多态）是一种类型多态，其中子类型是一种与另一种数据类型（超类型）相关的数据类型可替代性，意味着编写为对超类型的元素进行操作的程序元素（通常是子例程或函数）也可以对子类型的元素进行操作。

注意：子类型表示基类，子类型表示继承的类。

关于亚型多态性的进一步阅读

Technical Answer: Dynamic Dispatch

如果你有一个指向基类的指针，那么方法的调用（声明为virtual）将被调度到创建对象的实际类的方法。这就是Subtype Polymorphism的实现方式是C ++。

进一步阅读C ++和动态调度中的多态性

Implementation Answer: Creates vtable entry

对于方法上的每个修饰符“virtual”，C ++编译器通常在声明方法的类的vtable中创建一个条目。这就是C ++编译器实现Dynamic Dispatch的常见方式。

进一步阅读vtables

https://en.wikipedia.org/wiki/Virtual_method_table

示例代码

#include <iostream>

using namespace std;

class Animal {
public:
    virtual void MakeTypicalNoise() = 0; // no implementation needed, for abstract classes
    virtual ~Animal(){};
};

class Cat : public Animal {
public:
    virtual void MakeTypicalNoise()
    {
        cout << "Meow!" << endl;
    }
};

class Dog : public Animal {
public:
    virtual void MakeTypicalNoise() { // needs to be virtual, if subtype polymorphism is also needed for Dogs
        cout << "Woof!" << endl;
    }
};

class Doberman : public Dog {
public:
    virtual void MakeTypicalNoise() {
        cout << "Woo, woo, woow!";
        cout << " ... ";
        Dog::MakeTypicalNoise();
    }
};

int main() {

    Animal* apObject[] = { new Cat(), new Dog(), new Doberman() };

    const   int cnAnimals = sizeof(apObject)/sizeof(Animal*);
    for ( int i = 0; i < cnAnimals; i++ ) {
        apObject[i]->MakeTypicalNoise();
    }
    for ( int i = 0; i < cnAnimals; i++ ) {
        delete apObject[i];
    }
    return 0;
}

示例代码的输出

Meow!
Woof!
Woo, woo, woow! ... Woof!

代码示例的UML类图

Answer 14

我认为你指的是一旦将方法声明为虚拟，你就不需要在覆盖中使用'virtual'关键字。

class Base { virtual void foo(); };

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

如果你没有在Base的foo声明中使用'virtual'，那么Derived的foo就会隐藏它。

Answer 15

这是前两个答案的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的say（）方法。

$ 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的say（）方法，因为Dog是它们的对象类型。除非没有定义[Dog's's（）“woof”]方法，否则它将是在类树中首先搜索的方法，即派生类可以覆盖其基类的方法[Animal's's（（））。

$ 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 are effectively virtual中的所有类属性（数据和方法）。由于所有对象都是在运行时动态创建的，因此没有类型声明或需要关键字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为d）返回True，它们的值与0xb79f72cc>处的<main.Dog对象相同。

Answer 16

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

Answer 17

你熟悉函数指针吗？虚函数是一个类似的想法，除了您可以轻松地将数据绑定到虚函数（作为类成员）。将数据绑定到函数指针并不容易。对我来说，这是主要的概念区别。这里有很多其他答案只是说“因为......多态性！”

Answer 18

底线是虚拟功能使生活更轻松。让我们使用M Perry的一些想法，并描述如果我们没有虚函数会发生什么，而只能使用成员函数指针。我们在没有虚函数的正常估计中：

 class base {
 public:
 void helloWorld() { std::cout << "Hello World!"; }
  };

 class derived: public base {
 public:
 void helloWorld() { std::cout << "Greetings World!"; }
 };

 int main () {
      base hwOne;
      derived hwTwo = new derived();
      base->helloWorld(); //prints "Hello World!"
      derived->helloWorld(); //prints "Hello World!"

好的，这就是我们所知道的。现在让我们尝试使用成员函数指针：

 #include <iostream>
 using namespace std;

 class base {
 public:
 void helloWorld() { std::cout << "Hello World!"; }
 };

 class derived : public base {
 public:
 void displayHWDerived(void(derived::*hwbase)()) { (this->*hwbase)(); }
 void(derived::*hwBase)();
 void helloWorld() { std::cout << "Greetings World!"; }
 };

 int main()
 {
 base* b = new base(); //Create base object
 b->helloWorld(); // Hello World!
 void(derived::*hwBase)() = &derived::helloWorld; //create derived member 
 function pointer to base function
 derived* d = new derived(); //Create derived object. 
 d->displayHWDerived(hwBase); //Greetings World!

 char ch;
 cin >> ch;
 }

虽然我们可以使用成员函数指针做一些事情，但它们并不像虚函数那样灵活。在类中使用成员函数指针是很棘手的;成员函数指针几乎，至少在我的实践中，总是必须在main函数中调用，或者在成员函数中调用，如上例所示。

另一方面，虚函数虽然可能有一些函数指针开销，但确实可以大大简化事情。

编辑：还有另一种类似eddietree的方法：c++ virtual function vs member function pointer (performance comparison)。

Answer 19

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

    cout << d->Says();   // always Woof
    cout << a->Says();   // Woof or ?, depends on virtual
}

Answer 20

您需要虚拟方法来实现安全的向下转换，简单和简洁。

这就是虚拟方法的作用：它们安全地向下转换，具有明显简单和简洁的代码，避免了在您本来可能拥有的更复杂和冗长的代码中的不安全手动转换。

Non-virtual method ⇒ static binding

以下代码故意“不正确”。它没有将value方法声明为virtual，因此产生一个意外的“错误”结果，即0：

#include <iostream>
using namespace std;

class Expression
{
public:
    auto value() const
        -> double
    { return 0.0; }         // This should never be invoked, really.
};

class Number
    : public Expression
{
private:
    double  number_;

public:
    auto value() const
        -> double
    { return number_; }     // This is OK.

    Number( double const number )
        : Expression()
        , number_( number )
    {}
};

class Sum
    : public Expression
{
private:
    Expression const*   a_;
    Expression const*   b_;

public:
    auto value() const
        -> double
    { return a_->value() + b_->value(); }       // Uhm, bad! Very bad!

    Sum( Expression const* const a, Expression const* const b )
        : Expression()
        , a_( a )
        , b_( b )
    {}
};

auto main() -> int
{
    Number const    a( 3.14 );
    Number const    b( 2.72 );
    Number const    c( 1.0 );

    Sum const       sum_ab( &a, &b );
    Sum const       sum( &sum_ab, &c );

    cout << sum.value() << endl;
}

在被称为“坏”的行中，调用Expression::value方法，因为静态已知类型（编译时已知的类型）是Expression，而value方法不是虚拟的。

Virtual method ⇒ dynamic binding.

在静态已知类型value中将virtual声明为Expression可确保每个调用将检查这是什么实际类型的对象，并为该动态类型调用value的相关实现：

#include <iostream>
using namespace std;

class Expression
{
public:
    virtual
    auto value() const -> double
        = 0;
};

class Number
    : public Expression
{
private:
    double  number_;

public:
    auto value() const -> double
        override
    { return number_; }

    Number( double const number )
        : Expression()
        , number_( number )
    {}
};

class Sum
    : public Expression
{
private:
    Expression const*   a_;
    Expression const*   b_;

public:
    auto value() const -> double
        override
    { return a_->value() + b_->value(); }    // Dynamic binding, OK!

    Sum( Expression const* const a, Expression const* const b )
        : Expression()
        , a_( a )
        , b_( b )
    {}
};

auto main() -> int
{
    Number const    a( 3.14 );
    Number const    b( 2.72 );
    Number const    c( 1.0 );

    Sum const       sum_ab( &a, &b );
    Sum const       sum( &sum_ab, &c );

    cout << sum.value() << endl;
}

这里的输出应该是6.86，因为虚拟方法被虚拟调用。这也称为动态绑定调用。执行一点检查，查找实际动态类型的对象，并调用该动态类型的相关方法实现。

相关实现是最具体（最派生）类中的实现。

请注意，此处派生类中的方法实现未标记为virtual，而是标记为override。它们可能被标记为virtual，但它们是自动虚拟的。 override关键字确保如果某个基类中没有这样的虚方法，那么您将得到一个错误（这是可取的）。

The ugliness of doing this without virtual methods

如果没有virtual，就必须实现一些动态绑定的Do It Yourself版本。这通常涉及不安全的手动向下转换，复杂性和冗长。

对于单个函数的情况，就像这里一样，只需将函数指针存储在对象中并通过该函数指针调用即可，但即使这样，它也会涉及一些不安全的向下转换，复杂性和冗长，即：

#include <iostream>
using namespace std;

class Expression
{
protected:
    typedef auto Value_func( Expression const* ) -> double;

    Value_func* value_func_;

public:
    auto value() const
        -> double
    { return value_func_( this ); }

    Expression(): value_func_( nullptr ) {}     // Like a pure virtual.
};

class Number
    : public Expression
{
private:
    double  number_;

    static
    auto specific_value_func( Expression const* expr )
        -> double
    { return static_cast<Number const*>( expr )->number_; }

public:
    Number( double const number )
        : Expression()
        , number_( number )
    { value_func_ = &Number::specific_value_func; }
};

class Sum
    : public Expression
{
private:
    Expression const*   a_;
    Expression const*   b_;

    static
    auto specific_value_func( Expression const* expr )
        -> double
    {
        auto const p_self  = static_cast<Sum const*>( expr );
        return p_self->a_->value() + p_self->b_->value();
    }

public:
    Sum( Expression const* const a, Expression const* const b )
        : Expression()
        , a_( a )
        , b_( b )
    { value_func_ = &Sum::specific_value_func; }
};


auto main() -> int
{
    Number const    a( 3.14 );
    Number const    b( 2.72 );
    Number const    c( 1.0 );

    Sum const       sum_ab( &a, &b );
    Sum const       sum( &sum_ab, &c );

    cout << sum.value() << endl;
}

一种看待这种情况的积极方式是，如果您遇到如上所述的不安全的向下转换，复杂性和冗长，那么通常虚拟方法或方法确实可以提供帮助。

Answer 21

虚函数用于支持运行时多态性。

也就是说，virtual关键字告诉编译器不要在编译时决定（函数绑定），而是将其推迟运行时“。

您可以通过在其基类声明中使用关键字virtual来使函数虚拟化。例如， class Base { virtual void func(); }
当基类具有虚拟成员函数时，从基类继承的任何类都可以使用完全相同的原型重新定义函数，即只能重新定义功能，而不能重新定义函数的接口。 class Derive : public Base { void func(); }
Base类指针可用于指向Base类对象以及Derived类对象。
当使用Base类指针调用虚函数时，编译器在运行时决定调用哪个版本的函数 - 即Base类版本或重写的Derived类版本。这称为运行时多态性。

Answer 22

如果基类是Base，派生类是Der，你可以有一个Base *p指针，它实际上指向Der的一个实例。当你调用p->foo();时，如果foo不是虚拟的，那么Base的版本就会执行，而忽略了p实际上指向Der的事实。如果foo是虚拟的，p->foo()执行foo的“最底层”覆盖，完全考虑指向项的实际类。因此，虚拟和非虚拟之间的区别实际上非常重要：前者允许运行时polymorphism，OO编程的核心概念，而后者则不然。

Answer 23

需要虚拟功能解释[易于理解]

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

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

Answer 24

您必须区分覆盖和重载。如果没有virtual关键字，则只会重载基类的方法。这意味着隐藏。假设你有一个基类Base和一个派生类Specialized，它们都实现了void foo()。现在你有一个指向Base的指针，指向Specialized的一个实例。当你在上面调用foo()时，你可以观察到virtual所做的区别：如果方法是虚拟的，将使用Specialized的实现，如果它缺失，将选择Base的版本。最好不要从基类重载方法。使一个方法非虚拟是作者的方式告诉你它在子类中的扩展是不打算的。

Answer 25

我想添加虚拟功能的另一个用途，虽然它使用与上述答案相同的概念，但我想它值得一提。

虚拟的解构器

考虑下面的这个程序，而不将Base类析构函数声明为虚拟; Cat的内存可能无法清除。

class Animal {
    public:
    ~Animal() {
        cout << "Deleting an Animal" << endl;
    }
};
class Cat:public Animal {
    public:
    ~Cat() {
        cout << "Deleting an Animal name Cat" << endl;
    }
};

int main() {
    Animal *a = new Cat();
    delete a;
    return 0;
}

输出：

Deleting an Animal

class Animal {
    public:
    virtual ~Animal() {
        cout << "Deleting an Animal" << endl;
    }
};
class Cat:public Animal {
    public:
    ~Cat(){
        cout << "Deleting an Animal name Cat" << endl;
    }
};

int main() {
    Animal *a = new Cat();
    delete a;
    return 0;
}

输出：

Deleting an Animal name Cat
Deleting an Animal

为什么我们需要C ++中的虚函数？

问题描述投票：1126回答：24

24个回答

快速回答：

OOP Answer: Subtype Polymorphism

关于亚型多态性的进一步阅读

Technical Answer: Dynamic Dispatch

进一步阅读C ++和动态调度中的多态性

Implementation Answer: Creates vtable entry

进一步阅读vtables

Non-virtual method ⇒ static binding

Virtual method ⇒ dynamic binding.

The ugliness of doing this without virtual methods

最新问题

为什么我们需要C ++中的虚函数？

问题描述 投票：1126回答：24

24个回答

快速回答：

OOP Answer: Subtype Polymorphism

关于亚型多态性的进一步阅读

Technical Answer: Dynamic Dispatch

进一步阅读C ++和动态调度中的多态性

Implementation Answer: Creates vtable entry

进一步阅读vtables

Non-virtual method ⇒ static binding

Virtual method ⇒ dynamic binding.

The ugliness of doing this without virtual methods

最新问题

问题描述投票：1126回答：24