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

快速回答：

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

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

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

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

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

---

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

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

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

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

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

这些方法留给界面用户来实现。它们对于创建和销毁必须继承IUnknown的某些对象至关重要。在这种情况下，运行时知道这三个方法，并期望在调用它们时实现它们。所以在某种意义上，它们充当了对象本身和使用该对象的任何事物之间的契约。

您需要虚拟方法来实现安全的下变频、简单和简洁。

这就是虚拟方法所做的：它们安全地向下转换，使用明显简单而简洁的代码，避免了在更复杂和冗长的代码中进行不安全的手动转换。

---

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

在静态已知类型表达式中将值声明为virtual可确保每次调用都会检查这是什么实际类型的对象，并调用该动态类型的值的相关实现：

#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。它们可以被标记为虚拟，但它们是自动虚拟的。override关键字确保如果某个基类中没有这样的虚拟方法，那么您将得到一个错误（这是可取的）。

---

The ugliness of doing this without virtual methods ==================================================

如果没有虚拟绑定，则必须实现一些自己动手版本的动态绑定。这通常涉及不安全的手动降级、复杂性和冗长。

对于单个函数的情况，如这里所示，将函数指针存储在对象中并通过该函数指针进行调用就足够了，但即使如此，它也会涉及一些不安全的下变频、复杂性和冗长性，即：

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

看待这一点的一种积极方式是，如果您遇到了如上所述的不安全的下变频、复杂性和冗长，那么通常一个或多个虚拟方法确实会有帮助。

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

假设您有以下两个类：

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

完成。

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

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

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

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

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