我正在学习C++,我刚刚开始学习虚拟函数。

从我(在书中和网上)读到的内容来看,虚拟函数是基类中的函数,可以在派生类中重写。

但在本书的早些时候,当我学习基本继承时,我能够在派生类中重写基函数,而不使用虚函数。

那么我在这里错过了什么?我知道虚拟函数还有很多,它似乎很重要,所以我想清楚它到底是什么。我只是在网上找不到一个直截了当的答案。


当前回答

我以对话的形式给出了答案,以便更好地阅读:


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

因为多态性。

什么是多态性?

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

多态性的定义是如何导致对虚拟函数的需求的?

嗯,通过早期绑定。

什么是早期绑定?

C++中的早期绑定(编译时绑定)意味着在执行程序之前,函数调用是固定的。

所以

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

如果这不是我们想要的,为什么允许这样做?

因为我们需要多态性!

那么多态性的好处是什么?

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

我仍然不知道虚拟函数有什么好处。。。!这是我的第一个问题!

嗯,这是因为你问得太快了!

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

假设您使用基指针调用了一个函数,该函数具有来自其派生类之一的对象地址。正如我们上面所讨论的,在运行时,这个指针会被取消引用,但是,到目前为止,我们希望“从我们的派生类”执行一个方法(==成员函数)!然而,基类中已经定义了相同的方法(具有相同标头的方法),那么为什么您的程序要费心选择另一个方法呢?换言之,我的意思是,你怎么能把这种情况与我们以前通常看到的情况区分开来?

简单的答案是“基类中的一个虚拟成员函数”,稍长一点的答案是,“在这一步,如果程序在基类中看到一个虚拟函数,它知道(意识到)您正在尝试使用多态性”,因此去到派生类(使用v-table,一种后期绑定形式),发现另一个方法具有相同的头,但预期实现不同。

为什么实施不同?

你这个笨蛋!去读一本好书吧!

好吧,等等,等等,当他/她可以简单地使用派生类型指针时,为什么还要麻烦使用基指针呢?你是法官,所有这些头疼值得吗?看看这两个片段:

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

事实上,这可能也是一个虚构的例子!

其他回答

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

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

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

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

也就是说,virtual关键字告诉编译器不要在编译时做出(函数绑定的)决定,而是推迟到运行时”。

您可以通过在函数的基类声明中的关键字virtual之前使其成为虚拟函数。例如类基础{虚虚函数();}当基类具有虚拟成员函数时,从基类继承的任何类都可以使用完全相同的原型重新定义该函数,即只能重新定义功能,而不能重新定义函数的接口。类派生:公共基{void函数();}基类指针可用于指向基类对象和派生类对象。当使用基类指针调用虚拟函数时,编译器在运行时决定要调用函数的哪个版本(即基类版本或重写的派生类版本)。这被称为运行时多态性。

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

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

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

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