В чём разница между dynamic_cast и reinterpret_cast?

В чём разница между dynamic_cast и reinterpret_cast?

Это два совершенно разных оператора приведения типов в C++, которые решают разные задачи. dynamic_cast — безопасный, с проверкой типов, а reinterpret_cast — опасный, просто переинтерпретирует биты в памяти.

dynamic_cast — безопасное приведение типов

Основное назначение: Приведение указателей или ссылок в иерархии наследования с проверкой валидности типа во время выполнения (Runtime Type Information, RTTI).

Синтаксис:

DerivedClass* derived = dynamic_cast<DerivedClass*>(basePointer);

Как работает:

#include <iostream>
#include <memory>

class Animal {
public:
    virtual ~Animal() {}  // Обязателен виртуальный деструктор!
    virtual void speak() = 0;
};

class Dog : public Animal {
public:
    void speak() override { std::cout << "Woof!" << std::endl; }
    void fetch() { std::cout << "Fetching ball..." << 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>();
    
    // dynamic_cast проверит, действительно ли это Dog
    Dog* dog = dynamic_cast<Dog*>(animal.get());
    
    if (dog != nullptr) {
        std::cout << "Это Dog!" << std::endl;
        dog->fetch();  // Вызов специфичного для Dog метода
    } else {
        std::cout << "Это не Dog" << std::endl;
    }
    
    // Попытка привести к Cat
    Cat* cat = dynamic_cast<Cat*>(animal.get());
    if (cat != nullptr) {
        std::cout << "Это Cat!" << std::endl;
    } else {
        std::cout << "Это не Cat" << std::endl;  // Выведется это
    }
    
    return 0;
}

Требования для dynamic_cast:

1. Виртуальный деструктор в базовом классе — обязателен!
2. Указатель или ссылка — нельзя использовать с объектами по значению
3. RTTI включен — компилятор должен иметь информацию о типах (-frtti в GCC)

Результаты:

• При приведении указателя: возвращает nullptr если приведение неверно
• При приведении ссылки: выбрасывает исключение std::bad_cast если приведение неверно

// С ссылкой — исключение
try {
    Dog& dog_ref = dynamic_cast<Dog&>(*animal);  // RTTI проверка
    dog_ref.fetch();
} catch (const std::bad_cast& e) {
    std::cout << "Casting error: " << e.what() << std::endl;
}

Временная стоимость:

// dynamic_cast требует поиска в таблице виртуальных функций
// Примерная стоимость: 50-200 CPU cycles в зависимости от глубины иерархии
Dog* dog = dynamic_cast<Dog*>(animal);  // Медленнее, чем static_cast

reinterpret_cast — опасное переинтерпретирование

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

Синтаксис:

DerivedClass* derived = reinterpret_cast<DerivedClass*>(somePointer);

Пример — опасный код:

#include <iostream>
#include <cstring>

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

class Dog : public Animal {
public:
    void bark() { std::cout << "Woof!" << std::endl; }
};

int main() {
    int x = 42;
    
    // УЖАСНО! Переинтерпретируем int как указатель на Dog
    Dog* dog = reinterpret_cast<Dog*>(&x);
    dog->bark();  // Undefined behavior! Может крашнуть
    
    return 0;
}

Когда reinterpret_cast оправдан:

1. Работа с сырой памятью (raw pointers/bytes):

void processBuffer(void* buffer, size_t size) {
    // Переинтерпретируем void* как byte array
    unsigned char* bytes = reinterpret_cast<unsigned char*>(buffer);
    
    for (size_t i = 0; i < size; ++i) {
        std::cout << (int)bytes[i] << " ";
    }
}

1. Работа с сокетами и системными вызовами:

#include <sys/socket.h>
#include <netinet/in.h>

struct sockaddr_in server_addr;
// ...
send(socket_fd, reinterpret_cast<char*>(&server_addr), sizeof(server_addr), 0);

1. Сериализация/десериализация:

struct Point { float x, y; };

Point p = {1.5f, 2.5f};
byte* serialized = reinterpret_cast<byte*>(&p);
// Отправить serialized по сети

1. Работа с функциями обратного вызова:

void callback(void* userData) {
    // userData на самом деле MyClass*
    MyClass* obj = reinterpret_cast<MyClass*>(userData);
    obj->doSomething();
}

MyClass obj;
registerCallback(&callback, reinterpret_cast<void*>(&obj));

Прямое сравнение

#include <iostream>
#include <memory>

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

class Derived : public Base {
public:
    void derivedMethod() { std::cout << "Derived method" << std::endl; }
};

int main() {
    std::unique_ptr<Base> base = std::make_unique<Derived>();
    int unrelatedVar = 12345;
    
    // === dynamic_cast: БЕЗОПАСНО ===
    Derived* d1 = dynamic_cast<Derived*>(base.get());
    if (d1) {
        d1->derivedMethod();  // Работает
    }
    
    // === reinterpret_cast на неправильный тип: ОПАСНО ===
    Derived* d2 = reinterpret_cast<Derived*>(&unrelatedVar);
    // d2->derivedMethod();  // Undefined behavior!
    
    // === reinterpret_cast для сырой памяти: приемлемо ===
    unsigned char* bytes = reinterpret_cast<unsigned char*>(base.get());
    std::cout << "First byte: " << (int)bytes[0] << std::endl;  // OK
    
    return 0;
}

Таблица сравнения

Практические примеры в Backend

1. Безопасный полиморфизм (dynamic_cast):

class RequestHandler {
public:
    virtual ~RequestHandler() {}
    virtual void handle(Request& req) = 0;
};

class JSONHandler : public RequestHandler {
public:
    void handle(Request& req) override { /* ... */ }
    void parseJSON(const std::string& json) { /* ... */ }
};

// В серверном коде
void processRequest(RequestHandler* handler, Request& req) {
    JSONHandler* json_handler = dynamic_cast<JSONHandler*>(handler);
    if (json_handler) {
        json_handler->parseJSON(req.body);
    }
    handler->handle(req);
}

2. Низкоуровневая сетевая программа (reinterpret_cast):

struct NetworkPacket {
    uint32_t header;
    uint64_t timestamp;
    char data[256];
};

void sendPacket(int socket, const NetworkPacket& packet) {
    const char* bytes = reinterpret_cast<const char*>(&packet);
    send(socket, bytes, sizeof(NetworkPacket), 0);
}

NetworkPacket receivePacket(int socket) {
    char buffer[sizeof(NetworkPacket)];
    recv(socket, buffer, sizeof(NetworkPacket), 0);
    return *reinterpret_cast<NetworkPacket*>(buffer);
}

Общее правило

Динамический полиморфизм в иерархии классов?
→ Используй dynamic_cast

Работаешь с сырой памятью/системными вызовами?
→ Используй reinterpret_cast

Не уверен?
→ Скорее всего нужен dynamic_cast

Рекомендации

• Предпочитай dynamic_cast для работы с полиморфизмом
• Минимизируй использование reinterpret_cast — это признак опасного кода
• Добавляй комментарии при использовании reinterpret_cast
• Тестируй тщательно код с reinterpret_cast
• Рассмотри альтернативы (std::variant, std::any) перед reinterpret_cast