Какие знаешь виды cast?

Виды приведения типов (Cast) в C++

C++ предоставляет четыре специальных оператора приведения типов (cast), каждый с определённой целью и семантикой. Понимание различий между ними критично для написания безопасного и мотивированного кода. Это отличает опытного разработчика от новичка.

1. static_cast — Статическое приведение типов

Используется для приведения типов, которые гарантированно безопасны на уровне типов во время компиляции:

#include <iostream>
#include <vector>

int main() {
    // Числовые типы
    double d = 3.14;
    int i = static_cast<int>(d);  // 3
    
    // Указатели и ссылки в иерархии классов
    class Base { };
    class Derived : public Base { };
    
    Derived derived;
    Base& base_ref = derived;  // Уже Base&
    Derived& derived_ref = static_cast<Derived&>(base_ref);  // Down cast
    
    // Void указатели
    void* ptr = &i;
    int* int_ptr = static_cast<int*>(ptr);
    
    // Удаление const (в сочетании с const_cast)
    const int ci = 5;
    int* ptr_to_non_const = const_cast<int*>(&ci);
    
    std::cout << "i: " << i << std::endl;
    return 0;
}

Особенности:

• Проверяется на уровне компилятора
• Может привести к неопределённому поведению при неправильном использовании
• Используйте для известных, безопасных преобразований

2. dynamic_cast — Динамическое приведение типов

Используется для безопасного приведения указателей и ссылок в иерархии классов с RTTI (Runtime Type Information):

#include <iostream>
#include <memory>

class Animal {
public:
    virtual ~Animal() = default;
    virtual void speak() { std::cout << "..." << std::endl; }
};

class Dog : public Animal {
public:
    void speak() override { std::cout << "Woof!" << std::endl; }
    void fetch() { std::cout << "Fetching..." << std::endl; }
};

class Cat : public Animal {
public:
    void speak() override { std::cout << "Meow!" << std::endl; }
};

int main() {
    std::unique_ptr<Animal> animal = std::make_unique<Dog>();
    
    // Safe down cast с проверкой
    Dog* dog = dynamic_cast<Dog*>(animal.get());
    if (dog != nullptr) {
        dog->fetch();  // Безопасно вызываем Dog-специфичный метод
    }
    
    // С ссылками (выбрасывает std::bad_cast при ошибке)
    try {
        Dog& dog_ref = dynamic_cast<Dog&>(*animal);
        dog_ref.fetch();
    } catch (const std::bad_cast& e) {
        std::cout << "Not a Dog: " << e.what() << std::endl;
    }
    
    return 0;
}

Особенности:

• Требует виртуальных функций в базовом классе
• Проверка выполняется во время выполнения (немного медленнее)
• Возвращает nullptr для указателей при ошибке
• Выбрасывает std::bad_cast для ссылок при ошибке
• Используйте для polymorphic типов с неизвестным реальным типом

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

Эдинственный cast, предназначенный для работы с const и volatile квалификаторами:

#include <iostream>
#include <cstring>

void modify_string(char* str) {
    strcpy(str, "Modified");
}

int main() {
    // Удаление const
    const char* const_str = "Original";
    char* non_const_str = const_cast<char*>(const_str);
    // ВНИМАНИЕ: изменение const данных — undefined behavior!
    
    // Правильное использование: функция требует non-const, но данные const
    const int value = 42;
    const int* const_ptr = &value;
    int* non_const_ptr = const_cast<int*>(const_ptr);
    // Чтение через non_const_ptr безопасно, изменение — нет
    
    // Удаление volatile
    volatile int vol_val = 100;
    int val = const_cast<int&>(vol_val);
    
    std::cout << val << std::endl;
    return 0;
}

Особенности:

• Единственный способ удалить const/volatile
• Модификация const данных = undefined behavior
• Используйте только когда функция некорректно требует non-const параметр
• Альтернатива: переделать API, если возможно

4. reinterpret_cast — Переинтерпретация памяти

Мощный и опасный cast для переинтерпретации бинарного представления данных:

#include <iostream>
#include <cstring>

struct Point {
    float x, y;
};

int main() {
    // Указатели между несвязанными типами
    int value = 0x12345678;
    unsigned char* bytes = reinterpret_cast<unsigned char*>(&value);
    
    std::cout << "Bytes: ";
    for (int i = 0; i < sizeof(int); ++i) {
        printf("%02X ", bytes[i]);
    }
    std::cout << std::endl;
    
    // Конвертация указателя в целое число и обратно
    int* ptr = new int(42);
    uintptr_t address = reinterpret_cast<uintptr_t>(ptr);
    int* restored_ptr = reinterpret_cast<int*>(address);
    
    std::cout << "Value: " << *restored_ptr << std::endl;
    delete ptr;
    
    // Опасный пример: интерпретация float как int
    float f = 3.14f;
    int i = reinterpret_cast<int&>(f);  // Получаем бинарное представление
    std::cout << "Float as int: " << i << std::endl;
    
    return 0;
}

Особенности:

• Самый опасный cast — переинтерпретирует память как другой тип
• Зависит от архитектуры (endianness, выравнивания)
• Часто вызывает undefined behavior
• Используйте только для: serialization, low-level programming, optimization в критичных местах
• Почти всегда есть безопаснее способ

Сравнение четырёх cast'ов

Практические рекомендации

// Хорошо: используем dynamic_cast для безопасности
if (Dog* dog = dynamic_cast<Dog*>(animal)) {
    dog->fetch();
}

// Хорошо: static_cast для известных преобразований
int value = static_cast<int>(3.14);

// Редко: const_cast только если нет выбора
const_cast<int&>(const_value) = 42;  // Undefined if const_value is actually const

// Избегайте: reinterpret_cast, если есть альтернатива
reinterpret_cast<int&>(float_value);  // Undefined behavior

Старый C-style cast

В старом коде можно встретить C-style cast, который опасен и неоднозначен:

// Не используйте
int i = (int)3.14;         // static_cast
Dog* dog = (Dog*)animal;   // static_cast или reinterpret_cast?
int* ptr = (int*)void_ptr; // reinterpret_cast?

// Вместо этого явно указывайте нужный cast
int i = static_cast<int>(3.14);
Dog* dog = dynamic_cast<Dog*>(animal);
int* ptr = static_cast<int*>(void_ptr);

Вывод: Предпочитайте dynamic_cast для полиморфизма, static_cast для известных типов, минимизируйте const_cast, избегайте reinterpret_cast без крайней необходимости. Это делает код более читаемым и безопасным.