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

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

Короче:

• static_cast<>() дает вам возможность проверки времени компиляции, C-Style литье не делает.
• static_cast<>() можно легко заметить где-нибудь внутри исходного кода на С++; в отличие от C_Style литье сложнее обнаружить.
• Намерения передаются гораздо лучше с использованием С++-трансляций.

Подробнее:

Статическое преобразование выполняет преобразования между совместимыми типами. Это похож на C-стиль, но более ограничительный. Например, приведение в стиле C позволит целочисленному указателю указывать на char.

char c = 10;       // 1 byte
int *p = (int*)&c; // 4 bytes

Так как это приводит к 4-байтовому указателю, указывающему на 1 байт выделенного память, запись на этот указатель вызовет ошибку во время выполнения или перезапишет некоторую соседнюю память.

*p = 5; // run-time error: stack corruption

В отличие от стилей в стиле C статическая броска позволит компилятор для проверки того, что типы данных указателя и указателя совместимый, что позволяет программисту поймать эту ошибку назначение указателя во время компиляции.

int *q = static_cast<int*>(&c); // compile-time error

Дополнительная информация:
В чем разница между static_cast < > и литью стиля C
и
Обычный листинг против static_cast vs. dynamic_cast

Вопрос больше, чем просто использовать wither static_cast или C style casting, потому что есть разные вещи, которые случаются при использовании стилей стиля C. Операторы литья С++ предназначены для того, чтобы сделать эти операции более явными.

На поверхности static_cast и стили стиля C выглядят одинаково, например, при переносе одного значения в другое:

int i;
double d = (double)i;                  //C-style cast
double d2 = static_cast<double>( i );  //C++ cast

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

class A {};
class B : public A {};

A* a = new B;
B* b = (B*)a;                                  //(1) what is this supposed to do?

char* c = (char*)new int( 5 );                 //(2) that weird?
char* c1 = static_cast<char*>( new int( 5 ) ); //(3) compile time error

В этом примере (1) возможно ОК, потому что объект, на который указывает A, действительно является экземпляром B. Но что, если вы не знаете в тот момент кода, что на самом деле указывает? (2) может быть совершенно законным (вам нужно только посмотреть на один байт целого числа), но это также может быть ошибкой, и в этом случае ошибка будет приятной, например (3). Операторы литья С++ предназначены для выявления этих проблем в коде, предоставляя при этом ошибки времени компиляции или времени выполнения.

Итак, для строгой "кавычки значений" вы можете использовать static_cast. Если вы хотите, чтобы полиморфное литье указателей во время выполнения использовало dynamic_cast. Если вы действительно хотите забыть о типах, вы можете использовать reintrepret_cast. И просто выкинуть const из окна есть const_cast.

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

static_cast означает, что вы не можете случайно const_cast или reinterpret_cast, что хорошо.

Это о том, какую степень безопасности вы хотите навязать.

Когда вы пишете (bar) foo (что эквивалентно reinterpret_cast<bar> foo, если вы не предоставили оператор преобразования типа), вы говорите компилятору, чтобы игнорировать безопасность типа и просто делайте, как сказано.

Когда вы пишете static_cast<bar> foo, вы просите компилятор, по крайней мере, проверить, что преобразование типа имеет смысл и для интегральных типов вставить код преобразования.

EDIT 2014-02-26

Я написал этот ответ более 5 лет назад, и я понял, что это неправильно. (См. Комментарии.) Но он по-прежнему получает upvotes!

• Позволяет легко найти отливки в ваш код с использованием grep или аналогичного инструменты.
• Указывает, какой вид   вы делаете, и занимаетесь   компилятор поможет в его обеспечении.   Если вы хотите только отбросить   const-ness, то вы можете использовать   const_cast, который не позволит вам   делать другие типы конверсий.
• Каста по своей природе уродливы - вы как       программист бросает вызов тому, как       компилятор обычно обрабатывал ваши       код. Вы говорите       компилятор: "Я знаю лучше тебя".       В этом случае имеет смысл       что выполнение броска должно быть       умеренно болезненное дело, и       что они должны       кода, поскольку они являются вероятным источником       проблем.

См. Эффективный С++ Введение

C Стили стиля легко пропустить в блоке кода. Стили стиля С++ - это не только лучшая практика; они обеспечивают гораздо большую степень гибкости.

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

static_cast предлагает хорошее преобразование для числовых типов, например. от enum до int или ints до float или любых типов данных, которые вы уверены в типе. Он не выполняет проверку времени выполнения.

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

Есть несколько других, но это основные из них, с которыми вы столкнетесь.

static_cast, помимо манипулирования указателями на классы, также может использоваться для выполнения преобразований, явно определенных в классах, а также для выполнения стандартных преобразований между основными типами:

double d = 3.14159265;
int    i = static_cast<int>(d);