В чем разница между regular cast, static_cast и dynamic_cast в C++?

Краткий ответ: выбирайте cast по смыслу, а не по привычке

В C++ четыре основных приведения, и каждое решает свою задачу. Ваш главный принцип: используйте самый узкий и безопасный cast, который подходит для ситуации. C-style cast (он же (Type)expr) — это "швейцарский нож", который может делать почти всё: const_cast, static_cast, reinterpret_cast и даже их комбинации. Именно из-за этой всеядности он опасен — вы не контролируете, что именно произойдет.

Разбор ваших вариантов

1. C-style cast: (Circle*)s

Компилятор попробует сначала static_cast, потом const_cast, потом reinterpret_cast — в зависимости от типов. Если s на самом деле указывает на Rectangle, то static_cast сработает (ведь оба класса наследуют Shape), но вызов drawCircle() приведет к неопределенному поведению (UB). Компилятор вас не предупредит — это и есть главная проблема.

2. static_cast: static_cast<Circle*>(s)

Этот cast выполняется на этапе компиляции. Он работает только для родственных типов (наследование) или для стандартных преобразований (int→float). Он не проверяет, является ли объект на самом деле Circle — вы как бы говорите компилятору: "я знаю, что делаю, поверь мне". Если ошиблись — UB. Используйте его, когда абсолютно уверены в типе объекта (например, после проверки через dynamic_cast или когда логика гарантирует тип).

3. dynamic_cast: dynamic_cast<Circle*>(s)

Это единственный cast, который выполняет проверку во время выполнения (runtime). Он работает только для полиморфных типов (класс должен иметь хотя бы одну виртуальную функцию — у вас есть виртуальный деструктор, всё ок). Если s не является Circle*, dynamic_cast вернет nullptr для указателей или бросит исключение std::bad_cast для ссылок. Это безопасно, но медленнее (использует RTTI — Run-Time Type Information).

Ответы на ваши вопросы

• Когда какой использовать?
  • dynamic_cast — когда нужна безопасная проверка типа в полиморфной иерархии. Например, обработка событий, где объект может быть разным.
  • static_cast — когда вы точно знаете тип (например, в закрытой иерархии, где логика исключает другие варианты). Также для примитивных типов (int→double).
  • reinterpret_cast — только для низкоуровневых преобразований (указатель на int, битовые шаблоны). Почти никогда не нужен в обычном коде.
  • const_cast — только для снятия const с уже не-const объекта (редкая необходимость).
• Почему C-style cast плох? Потому что он может сделать что угодно, включая опасные reinterpret_cast, и это не видно в коде. Например, (int*)myFloat сломает strict aliasing.
• static_cast от Rectangle* к Circle* — это законно с точки зрения компиляции, но только если между классами есть отношение наследования (прямое или косвенное). Если они не связаны, компилятор выдаст ошибку. Но если связаны — вы получите UB при вызове методов Circle на Rectangle.
• Производительность dynamic_cast — да, он медленнее (зависит от глубины иерархии и компилятора). Но в большинстве приложений это не критично. Если производительность критична, используйте виртуальные функции или паттерн Visitor вместо dynamic_cast.

Правильный паттерн

void process(Shape* s) {
    // Безопасно: проверяем тип
    if (Circle* c = dynamic_cast<Circle*>(s)) {
        c->drawCircle();
    } else if (Rectangle* r = dynamic_cast<Rectangle*>(s)) {
        r->drawRect();
    } else {
        // Обработка неизвестного типа
    }
}

Или еще лучше — используйте виртуальные функции, чтобы вообще избежать приведения:

class Shape {
public:
    virtual void draw() = 0;
    virtual ~Shape() {}
};

class Circle : public Shape {
    void draw() override { /* рисуем круг */ }
};

class Base { public: virtual ~Base() = default; };
class Derived : public Base { /* ... */ };

void process(Base* b) {
    // Мы точно знаем, что b — это Derived, потому что
    // только такие объекты передаются в этот обработчик
    Derived* d = static_cast<Derived*>(b);
    // Используем d...
}