Почему стоит использовать static_cast<int>(x) вместо (int)x или int(x) в C++?

Ключевое отличие: контроль и безопасность

Вы правы, что в простейшем случае (например, double → int) все три варианта дают одинаковый результат. Разница проявляется, когда вы начинаете работать с указателями, наследованием или перегрузками операторов. C-style cast — это «швейцарский нож», который пытается сделать всё сразу, иногда даже то, чего вы не ожидали.

Проблема C-style cast: неявная множественность

Один и тот же синтаксис (Type)x может выполнять четыре разных операции в зависимости от контекста:

• static_cast — стандартное преобразование (числа, указатели вверх/вниз по иерархии)
• const_cast — снятие константности
• reinterpret_cast — побитовое переосмысление (опасно!)
• dynamic_cast — безопасное приведение с RTTI (только для полиморфных классов)

Компилятор выбирает наиболее «агрессивную» из разрешённых операций. Пример опасного поведения:

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

class Derived : public Base {
public:
    void specificMethod() { std::cout << "Derived"; }
};

int main() {
    Base* ptr_base = new Base;
    // C-style cast: компилятор считает, что мы знаем, что делаем
    Derived* d = (Derived*)ptr_base; // OK для компилятора, UB на практике!
    d->specificMethod(); // Неопределённое поведение!

    // static_cast: компилятор проверит иерархию и выдаст ошибку
    // Derived* d2 = static_cast<Derived*>(ptr_base); // Ошибка компиляции!
}

В этом примере (Derived*) сработает, хотя ptr_base на самом деле не указывает на Derived. static_cast же проверит типы на этапе компиляции и запретит такое приведение (если нет полиморфной связи). C-style cast молча даёт «зелёный свет» любому reinterpret_cast, что часто приводит к трудноотловимым багам.

Ещё один подводный камень: случайное снятие const

const int value = 42;
int* p = (int*)&value; // C-style cast снимает const без предупреждения
*p = 100; // Неопределённое поведение (изменение const-объекта)

// static_cast не позволит этого:
// int* p2 = static_cast<int*>(&value); // Ошибка компиляции!

Производительность и читаемость

Производительность: Никакой разницы в скомпилированном коде нет. Все эти касты — чисто синтаксический сахар для компилятора. static_cast не генерирует дополнительных инструкций по сравнению с C-style cast.

Читаемость: static_cast<int>(d) сразу говорит: «здесь выполняется стандартное статическое приведение». C-style cast (int)d может означать что угодно — от простого преобразования до опасного reinterpret_cast. При код-ревью легче искать static_cast и понимать намерения автора.

Когда C-style cast всё же допустим?

Единственный легитимный случай — приведение числовых литералов для совместимости с C-библиотеками в стиле (int)3.14, и то многие предпочитают static_cast<int>(3.14). В современном C++ (C++17/20) использование C-style cast считается плохой практикой, если только вы не работаете с legacy-кодом.

Итог: static_cast — это явное указание намерений, защита от случайных ошибок и самодокументируемость кода. C-style cast — это «молоток», которым можно забить гвоздь, но можно и разбить монитор. Используйте правильный инструмент.