Реальный пример dynamic_cast на C ++

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

То есть двойная диспетчеризация затрагивает задействованные классы, в то время как dynamic_cast работает без знания приведения в классах.

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

Наконец, двойная отправка не обходится без проблем

Базовый класс Shape должен знать обо всех производных классах, что приводит к циклическим зависимостям. Если вы унаследовали новый класс от Shape (скажем, Triangle), вы должны обновить интерфейс Shape и интерфейс / реализацию всех других производных классов. В некоторых случаях это даже не вариант: у вас может не быть исходного кода для Shape, или вы не хотите или не можете его изменять.

Ограничение «вообще нельзя обойтись» слишком сильное. Любая функция C ++ может быть эмулирована в C. Все, что вам нужно сделать, чтобы обойти эту функцию, так сказать, - это использовать этот код C в C ++. Например, MFC, библиотека, зародившаяся еще до стандартизации языка 1998 года, предлагала и до сих пор предлагает свой собственный тип динамического преобразования.

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

#include <stdio.h>

void say( char const s[] ) { printf( "%s\n", s ); }

struct Event
{
    struct Handler
    {
        virtual void onEvent( Event& ) = 0;
    };

    virtual void dispatchTo( Handler& aHandler )
    {
        aHandler.onEvent( *this );
    }

    template< class SpecificEvent >
    static void dispatch( SpecificEvent& e, Handler& aHandler )
    {
        typedef typename SpecificEvent::Handler SpecificHandler;

        // The single dynamic cast:
        if( SpecificHandler* p = dynamic_cast<SpecificHandler*>( &aHandler ) )
        {
            p->onEvent( e );
        }
        else
        {
            e.Event::dispatchTo( aHandler );
        }
    }
};

struct FooEvent
    : Event
{
    struct Handler
    {
        virtual void onEvent( FooEvent& ) = 0;
    };

    virtual void dispatchTo( Event::Handler& aHandler )
    {
        dispatch( *this, aHandler );
    }
};

struct Plane
    : Event::Handler
{
    virtual void onEvent( Event& ) { say( "An event!" ); }
};

struct Fighter
    : Plane
    , FooEvent::Handler // Comment out this line to get "An event!".
{
    virtual void onEvent( FooEvent& ) { say( "Foo Fighter!" ); }
};

void doThingsTo( Plane& aPlane )
{
    FooEvent().dispatchTo( aPlane );
}

int main()
{
    Fighter plane;

    doThingsTo( plane );
}

Результатом этой программы будет Foo Fighter!.

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

Ура & hth.

Я лично использую его для работы с некоторыми частями моего игрового движка. У меня есть базовый класс сущностей, из которого я получаю различные другие сущности. Я привел их к типу базового класса, чтобы я мог легко сохранить их в связанном списке. Когда я хочу проверить, принадлежит ли конкретная запись в моем списке определенному объекту, я динамически привожу ее к этому типу. Если он возвращает ноль, значит, я знаю, что это не так.

Допустим, у нас есть библиотека, которую мы используем, которая предназначена для наследования некоторых типов из:

class A {};
class B : public A {};
class C : public B {};

И когда мы выводим наши типы, у нас есть некоторые вещи, общие для всех наших случаев:

class CommonStuff {};
class D : public CommonStuff, public C {};

Теперь, когда мы работаем с нашей библиотекой, есть обратный вызов, который принимает тип A & (или B & или C &)

void some_func(A& obj);

И предположим, что в этой функции ожидается полиморфное поведение, но нам нужно получить доступ к некоторым из наших CommonStuff:

void some_func(A& obj)
{
    CommonStuff& comn = dynamic_cast<CommonStuff&>(obj);
}

Поскольку нет прямой корреляции между A и CommonStuff, мы не можем использовать static_cast, reinterpret_cast, очевидно, не правильный выбор, поскольку он вводит нарезку. Единственный вариант - dyanmic_cast.

Теперь отнеситесь к этому с недоверием, потому что это можно обойти.

Вы часто можете заменить dynamic_cast ‹A *› (...), добавив виртуальную функцию в A. Однако, если A - это класс из сторонней библиотеки, вы не можете его изменить, поэтому вы не можете добавить виртуальную функцию к нему. Так что вам, возможно, придется использовать dynamic_cast.