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

Общее правило: избегайте C-style cast

В C++ четыре оператора приведения заменяют одно универсальное C-приведение (type). C-style cast может делать всё что угодно — от безопасного преобразования до опасного переинтерпретирования битов. Это затрудняет поиск ошибок. Каждый C++-оператор имеет строго определённую область применения.

1. static_cast — безопасное неявное преобразование

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

// Числовые типы
int a = 10;
double b = static_cast<double>(a); // int → double (без потерь)

// Приведение вверх по иерархии (upcast) — безопасно
class Base { ... };
class Derived : public Base { ... };
Derived d;
Base* base = static_cast<Base*>(&d); // OK, Derived — это Base

// Приведение вниз (downcast) — без проверки!
Base* basePtr = new Derived();
Derived* dPtr = static_cast<Derived*>(basePtr); // Опасно, если basePtr не указывает на Derived

Когда использовать: преобразования между числовыми типами, перечислениями, upcast по иерархии наследования, вызов конструктора с одним аргументом (например, static_cast<std::string>("hello")).

2. dynamic_cast — безопасное приведение с проверкой (только для полиморфных классов)

Работает только с классами, имеющими виртуальные функции. Проверяет тип объекта во время выполнения и возвращает nullptr (для указателей) или генерирует исключение std::bad_cast (для ссылок), если приведение невозможно.

class Base { virtual void f() {} };
class Derived : public Base {};

Base* base = new Base();
Base* derived = new Derived();

// Проверка: указывает ли base на Derived?
Derived* d1 = dynamic_cast<Derived*>(base);    // nullptr (base — это Base, не Derived)
Derived* d2 = dynamic_cast<Derived*>(derived); // OK, указатель на Derived

// Для ссылок — исключение
try {
    Derived& ref = dynamic_cast<Derived&>(*base);
} catch (std::bad_cast& e) {
    std::cerr << "Ошибка приведения: " << e.what() << "\n";
}

Когда использовать: нисходящее приведение (downcast), когда вы не уверены в реальном типе объекта. Требует RTTI (Runtime Type Information), что добавляет небольшие накладные расходы.

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

Единственный оператор, который может убрать const или volatile. Используется только в крайних случаях, когда API требует неконстантный указатель, но вы уверены, что объект не будет изменён.

const int x = 5;
int* ptr = const_cast<int*>(&x);
*ptr = 10; // НЕДОПУСТИМО! x изначально const, изменение — UB

// Корректный сценарий: функция, которая «обещает» не менять, но принимает неконстантный указатель
void legacy_func(int* p) { /* не изменяет *p */ }
const int data = 42;
legacy_func(const_cast<int*>(&data)); // OK, если legacy_func действительно не меняет

Важно: изменение объекта, который изначально был объявлен const, через const_cast — это неопределённое поведение. Используйте только для объектов, которые являются константными лишь по ссылке/указателю, но не по сути.

4. reinterpret_cast — низкоуровневое переинтерпретирование битов

Самый опасный оператор. Он просто переинтерпретирует биты одного типа как другой. Гарантии переносимости кода нет.

// Указатель → целое число (размер должен совпадать)
int a = 42;
uintptr_t addr = reinterpret_cast<uintptr_t>(&a);

// Преобразование между несвязанными типами указателей
char buffer[4];
int* pInt = reinterpret_cast<int*>(buffer); // Опасно! Выравнивание может быть нарушено

// Работа с битовыми полями в сырых данных
struct Packet { uint32_t header; uint8_t data[12]; };
uint8_t raw[16];
Packet* pkt = reinterpret_cast<Packet*>(raw); // Только если raw правильно выровнен

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

Итоговая таблица

• static_cast — безопасные, известные на этапе компиляции преобразования (числа, upcast, enum)
• dynamic_cast — downcast с проверкой времени выполнения (только полиморфные классы)
• const_cast — только для снятия const/volatile (с осторожностью)
• reinterpret_cast — только для низкоуровневой переинтерпретации битов

Если вам кажется, что нужен C-style cast — остановитесь и подумайте, какой из четырёх операторов на самом деле подходит. Это сделает код понятнее и безопаснее.

// 1. Числовые литералы в шаблонном коде
template<typename T>
T multiply(T a, T b) {
    return (T)(a * b); // Проще, чем static_cast<T>(a * b)
}

// 2. Совместимость с C-кодом
extern "C" void c_function(void* ptr);
int data = 42;
c_function((void*)&data); // В C нет static_cast

// 3. Приведение к void в макросах (например, подавление предупреждений)
#define UNUSED(x) (void)(x)