Когда использовать static_cast, dynamic_cast, const_cast и reinterpret_cast в C++?

Краткая шпаргалка по четырём cast-операторам C++

В C++ есть четыре стиля приведения типов, каждый со своим назначением. Использовать Си-стиль (type)value в современном C++ не рекомендуется, так как он может делать всё подряд и скрывает ошибки. Вот когда что применять:

1. static_cast — для явных, но разумных преобразований

Когда использовать: для преобразований между числовыми типами (int ↔ double, enum ↔ int), для upcast'а (производный → базовый) и для downcast'а, только если вы уверены в типе.

double pi = 3.14159;
int approx = static_cast<int>(pi); // 3

class Base { ... };
class Derived : public Base { ... };
Derived d;
Base* b = static_cast<Base*>(&d); // upcast — безопасно

// Downcast — опасно! Только если точно знаете, что b указывает на Derived
Derived* d2 = static_cast<Derived*>(b); // работает, но если b не Derived — UB

Важно: static_cast не проверяет тип во время выполнения. Если вы ошиблись — неопределённое поведение (UB).

2. dynamic_cast — для безопасного downcast'а с проверкой

Когда использовать: только для полиморфных классов (с виртуальными функциями) и только для downcast'а или кросс-каста. Возвращает nullptr для указателей или кидает std::bad_cast для ссылок, если преобразование невозможно.

class Base { public: virtual ~Base() = default; };
class Derived : public Base { public: void foo() {} };

Base* b1 = new Derived();
Base* b2 = new Base();

Derived* d1 = dynamic_cast<Derived*>(b1); // OK, d1 != nullptr
Derived* d2 = dynamic_cast<Derived*>(b2); // d2 == nullptr — безопасно

if (d2) d2->foo(); // проверка перед использованием

Минус: dynamic_cast медленнее (использует RTTI) и требует включённой поддержки RTTI в компиляторе.

3. const_cast — для снятия/добавления const/volatile

Когда использовать: только когда вы работаете с устаревшим кодом или API, который требует не-const указатель, но вы уверены, что объект не будет изменён. Никогда не используйте для изменения константного объекта!

void old_api(char* str); // старый код, который не меняет строку

const char* msg = "Hello";
old_api(const_cast<char*>(msg)); // OK, если old_api не пишет в str

// ПЛОХО:
const int x = 5;
int* px = const_cast<int*>(&x);
*px = 10; // UB! x может быть в read-only памяти

4. reinterpret_cast — для низкоуровневых битовых преобразований

Когда использовать: только в системном программировании, работе с железом, сериализации или при взаимодействии с Си-библиотеками. Преобразует тип указателя в другой тип указателя или в целое число (и обратно) без изменения битового представления.

// Пример: чтение float как последовательность байт
float f = 3.14f;
uint32_t* bits = reinterpret_cast<uint32_t*>(&f);
std::cout << std::hex << *bits; // битовое представление

// Преобразование указателя в число (для отладки)
int value = 42;
uintptr_t addr = reinterpret_cast<uintptr_t>(&value); // uintptr_t — целое, способное хранить указатель

Предупреждение: reinterpret_cast — самый опасный. Он ломает систему типов, и результат может быть непереносимым. Используйте только когда знаете, что делаете.

Ответ на ваш пример с ошибкой

Base* b = new Base();
Derived* d = static_cast<Derived*>(b); // UB! b не указывает на Derived
d->foo(); // краш или неопределённое поведение

Правильно было бы использовать dynamic_cast (если Base полиморфный) или пересмотреть дизайн — зачем вам downcast, если b на самом деле не Derived?

// Плохо: downcast
void process(Base* b) {
    if (auto* d = dynamic_cast<Derived*>(b)) {
        d->specificMethod();
    }
}

// Хорошо: виртуальная функция
class Base {
public:
    virtual void process() = 0;
};
class Derived : public Base {
    void process() override { specificMethod(); }
};