您需要使用虚拟方法来进行安全向下转换，简化和简洁。
这就是虚拟方法的作用：它们使用显然简单明了的代码安全地向下转换，避免了您本来会更复杂和冗长的代码中不安全的手动转换。
非虚拟方法⇒静态绑定
以下代码是有意的“不正确”。它没有将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方法不是虚拟的。
虚拟方法⇒动态绑定。
声明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关键字确保如果有没有在一些基础类这样的虚拟方法，那么你会得到一个错误（这是可取的）。
在没有虚拟方法的情况下这样做的丑陋
没有virtual人就必须实现动态绑定的“ 自己动手做”版本。通常，这就是不安全的手动下降，复杂性和冗长性。
对于单个函数，如此处所示，将函数指针存储在对象中并通过该函数指针进行调用就足够了，但是即使如此，它仍然涉及一些不安全的贬低，复杂性和冗长性：
#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;
}
一种看待这种情况的积极方法是，如果遇到上述不安全的向下转换，复杂性和冗长性，那么通常使用一种或多种虚拟方法确实可以提供帮助。
