Зачем нужен dynamic_cast?

#c++ #классы #указатели #rtti

class A;
class B : public A;

B* b;
A* a = dynamic_cast(b);  // 1
A* a = (A*)b;  // 2


Для чего нужен dynamic_cast? Какие преимущества имеет запись 1 по сравнению с записью
2 и какие недостатки? В каких случаях какой вариант следует использовать? 
    

Ответы

Ответ 1

Вообще-то, в том варианте, как вы записали, не нужно приводить ничего, потому что
объект производного класса уже ЯВЛЯЕТСЯ объектом базового. Так что можно просто писать

A * a = b;


А вот если наоборот - 

B * b = a;


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

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

void func(Base*b)
{
    ((Derived*)b)->derivedfunc();
}


Здесь вы вызываете функцию-член, которая есть у Derived, но которой нет в Base. Но
что будет, если вы действительно передадите в функцию указтель на Base? Указатель на
другого потомка Base, который ничего об этой функции не знает?

А dynamic_cast позволяет по крайней мере убедиться, что происходит именно то, что
нужно, т.е. что там действительно указатель на Derived.

Что до приведения в стиле C - (A*)b - то тут, пожалуй, ближе всего reinterpret_cast
- просто рассматривать биты как имеющие иной тип. Без каких-либо проверок. Что уже
опасно, но, по крайней мере, в тексте программы в глаза будет бросаться это длинное
слово - reinterpret_cast - как указатель на опасность. И это не шутка, это я повторяю
Страуструпа - насчет длинных неуклюжих названий ..._cast.

P.S. Мне нет нужды напоминать, что при использовании dynamic_cast требуется наличие
виртуальных функций, и пояснять, почему?


Ответ 2

Нет ни одной причины использовать запись типа 2. Она появилась как обеспечение совместимости
с приведением типов из С и старых версий С++.

По нынешним нормам НУЖНО использовать dynamic_cast.
Если Вы хотите понять чем отличаются разные варианты cast'ов - дайте знать. Но в
данном случае все тривиально. Мы приводим объект класса-потомка к базовому классу

Дополнительно обращу внимание, что cast'ы хороши, что они в принципе укладываются
в систему обработки исключений и дают человеческие коды ошибок. А использование c-style
приведения - это самый простой ( и не лучший!!! ) способ заткнуть компилятор. И замаскировать
ошибку, а потом героически пытаться ее найти и/или исправить


Ответ 3

dyanmic_cast нужен для того чтобы безопасно выполнить понижающее приведение(от типа
базового класса к типу наследника). Например

calss Base{
public:
    virtual ~Base(){}
};
calss A : public Base{};
calss B : public Base{};

void foo(A *a){
    Base *base = a;

    //1 Нормально скомпилируется. 
    //Приведение типа выполнится, но на этапе выполнения 
    //получится какая-то чепуха, причину которой будет 
    //найти ой как непросто
    B b1* = (B*)base; 

    //2 Полностью идентично 1. 
    //Просто такую запись проще найти при помощи grep 
    //или похожих средств. Так же static_cast не 
    //убирает модификаторы const и volatile, что в 
    //некоторых случая позволит избежать ошибок
    B b2* = static_cast(base); 

    //3 Также как и случаях 1 и 2 успешно скомпилируется. 
    //Но b3 будет равен 0. dynamic_cast используя RTTI 
    //определил что произошла попытка приведения к 
    //неправильному типу, и вернул 0.
    B b3* = dynamic_cast(base); 

    //Теперь мы можем написать
    if(b3 == 0){
        std::cerr << "что-то пошло не так\n";
    }
    //И быстро локализовать ошибку
}


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

Если использовать вместо указателей ссылки, то dyamic_cast будет выбрасывать исключение
std::bad_cast, если происходит неправильное приведение