Какие знаешь операторы приведения типов?

Четыре типа приведения типов в C++

C++ предоставляет четыре специализированных оператора приведения типов, каждый с определённой целью. Они безопаснее и яснее, чем C-style cast.

1. static_cast — наиболее часто используемый

Назначение: преобразование между связанными типами во время компиляции.

// Базовое преобразование числовых типов
int i = 42;
double d = static_cast<double>(i);  // 42.0

// Преобразование указателей в иерархии наследования (вверх всегда безопасно)
class Base { };
class Derived : public Base { };

Derived* derived = new Derived();
Base* base = static_cast<Base*>(derived);  // OK - вверх по иерархии

// Преобразование туда-сюда
Base* ptr = new Base();
Derived* down = static_cast<Derived*>(ptr);  // Опасно! Компилятор не проверит

// Преобразование в void*
int x = 10;
void* vptr = static_cast<void*>(&x);
int* iptr = static_cast<int*>(vptr);  // Вернули обратно

Когда использовать:

• Преобразование числовых типов
• Вверх по иерархии наследования (безопасно)
• Когда уверен в типе и хочешь обойти проверки

Когда НЕ использовать:

• Вниз по иерархии (используй dynamic_cast)
• Удаление const (используй const_cast)
• Преобразование между несвязанными типами

2. dynamic_cast — для безопасной работы с наследованием

Назначение: безопасное преобразование в иерархии наследования с проверкой во время выполнения.

class Animal { virtual ~Animal() {} };
class Dog : public Animal { };
class Cat : public Animal { };

Animal* animal = new Dog();

// Безопасное преобразование вниз
Dog* dog = dynamic_cast<Dog*>(animal);
if (dog != nullptr) {
    std::cout << "It's a dog!" << std::endl;
} else {
    std::cout << "Not a dog" << std::endl;
}

// Для ссылок
Dog& dog_ref = dynamic_cast<Dog&>(*animal);  // Выбросит std::bad_cast если неправильный тип

Важные моменты:

• Требует виртуального деструктора в базовом классе
• Работает только с полиморфными типами (с virtual методами)
• Проверка во время выполнения — стоит CPU

class NonPolymorphic { };  // Нет virtual методов
class Child : public NonPolymorphic { };

NonPolymorphic* ptr = new Child();
// Child* child = dynamic_cast<Child*>(ptr);  // ОШИБКА КОМПИЛЯЦИИ!

Когда использовать:

• Преобразование вниз по иерархии
• Когда нужна проверка типа во время выполнения
• С полиморфными классами

3. const_cast — удаление/добавление const

Назначение: изменить const квалификатор типа.

// Удаление const
const int* cptr = new int(42);
int* mptr = const_cast<int*>(cptr);
*mptr = 100;  // Работает, но опасно!

// Добавление const
int x = 10;
const int* const_ptr = const_cast<const int*>(&x);

// Удаление const из объекта
class MyClass {
public:
    void const_method() const {
        MyClass* non_const_this = const_cast<MyClass*>(this);
        // Теперь можешь вызвать non-const методы
    }
};

Когда использовать:

• Интеграция с legacy C кодом
• Рабочие функции, которые не модифицируют объект (но интерфейс требует non-const)
• Очень редко! Это обычно признак проблемы в дизайне

Когда НЕ использовать:

• const_cast на const объекты приводит к undefined behavior

const int x = 10;
int* ptr = const_cast<int*>(&x);
*ptr = 20;  // UNDEFINED BEHAVIOR! x всё ещё 10

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

Назначение: преобразование между несвязанными типами на уровне битов.

// Указатель в целое число
int* ptr = new int(42);
uintptr_t addr = reinterpret_cast<uintptr_t>(ptr);

// Целое число назад в указатель
int* restored = reinterpret_cast<int*>(addr);

// Один тип указателя в другой (опасно)
class A { };
class B { };

A* a = new A();
B* b = reinterpret_cast<B*>(a);  // Битовая переинтерпретация

Когда использовать:

• System programming (работа с адресами памяти)
• Serialization (преобразование объектов в байты)
• Очень редко

Когда НЕ использовать:

• Это наиболее опасный cast
• Часто указывает на ошибки в дизайне

Сравнение всех четырёх

class Base { virtual ~Base() {} };
class Derived : public Base { };

Base* base_ptr = new Derived();

// static_cast - вверх безопасен, вниз опасен
Derived* d1 = static_cast<Derived*>(base_ptr);  // Опасно!

// dynamic_cast - проверяет во время выполнения
Derived* d2 = dynamic_cast<Derived*>(base_ptr);  // Безопасно
if (!d2) std::cout << "Wrong type" << std::endl;

// const_cast - удаляет const
const int* const_ptr = new int(5);
int* mutable_ptr = const_cast<int*>(const_ptr);

// reinterpret_cast - переинтерпретирует биты
int* int_ptr = new int(10);
uintptr_t addr = reinterpret_cast<uintptr_t>(int_ptr);

Практический пример

class Shape { public: virtual ~Shape() {} };
class Circle : public Shape { };
class Rectangle : public Shape { };

std::vector<Shape*> shapes;
shapes.push_back(new Circle());
shapes.push_back(new Rectangle());

for (Shape* shape : shapes) {
    if (Circle* circle = dynamic_cast<Circle*>(shape)) {
        std::cout << "Found a circle" << std::endl;
    } else if (Rectangle* rect = dynamic_cast<Rectangle*>(shape)) {
        std::cout << "Found a rectangle" << std::endl;
    }
}

Правило выбора

1. static_cast — дефолт для преобразований типов
2. dynamic_cast — если работаешь с наследованием
3. const_cast — только если действительно нужно (редко)
4. reinterpret_cast — для low-level операций (очень редко)

Вывод

• C++-style cast'ы безопаснее C-style cast'ов
• static_cast — самый часто используемый
• dynamic_cast — безопасен для работы с наследованием
• const_cast и reinterpret_cast — экзотика, используй редко
• Всегда предпочитай явный cast плохому дизайну