Вам нужны виртуальные методы для безопасного понижения, простоты и лаконичности.

Это то, что делают виртуальные методы: они безопасно опущены, с явно простым и сжатым кодом, избегая небезопасных ручных отбросов в более сложных и подробный код, который вы в противном случае имели бы.

Не виртуальный метод & rArr; статическая привязка

Следующий код преднамеренно неправильный & rdquo ;. Он не объявляет метод value как virtual и поэтому создает непреднамеренное & ldquo; wrong & rdquo; результат, а именно 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;
}

В строке, прокомментированной как & ldquo; bad & rdquo; вызывается метод Expression::value, потому что статически известный тип (тип, известный во время компиляции) является Expression, а метод value не является виртуальным.

Виртуальный метод & rArr; динамическое связывание.

Объявление 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 гарантирует, что если в каком-либо базовом классе есть not такой виртуальный метод, вы получите ошибку (что желательно).

Уродство делать это без виртуальных методов

Без 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;
}

. Один положительный способ взглянуть на это - если вы столкнулись с небезопасным понижением, сложностью и многословием, как указано выше, виртуальный метод или методы могут действительно помочь.