Por que usar static_cast <int> (x) em vez de (int) x?

Ouvi dizer que a static_castfunção deve ser preferida ao estilo C ou simples ao estilo de função. Isso é verdade? Por quê?

A principal razão é que moldes clássicos C não fazem distinção entre o que chamamos static_cast<>(), reinterpret_cast<>(), const_cast<>(), e dynamic_cast<>(). Essas quatro coisas são completamente diferentes.

A static_cast<>()é geralmente seguro. Há uma conversão válida no idioma ou um construtor apropriado que o torna possível. A única vez que é um pouco arriscado é quando você baixa para uma classe herdada; você deve se certificar de que o objeto é realmente o descendente que você afirma ser, por meios externos ao idioma (como uma bandeira no objeto). A dynamic_cast<>()é seguro desde que o resultado seja verificado (ponteiro) ou uma possível exceção seja levada em consideração (referência).

A reinterpret_cast<>()(ou a const_cast<>()), por outro lado, é sempre perigoso. Você diz ao compilador: "confie em mim: eu sei que isso não se parece com um foo(parece que não é mutável), mas é".

O primeiro problema é que é quase impossível dizer qual deles ocorrerá em um elenco no estilo C, sem examinar pedaços de código grandes e dispersos e conhecer todas as regras.

Vamos assumir o seguinte:

class CDerivedClass : public CMyBase {...};
class CMyOtherStuff {...} ;

CMyBase  *pSomething; // filled somewhere

Agora, esses dois são compilados da mesma maneira:

CDerivedClass *pMyObject;
pMyObject = static_cast<CDerivedClass*>(pSomething); // Safe; as long as we checked

pMyObject = (CDerivedClass*)(pSomething); // Same as static_cast<>
                                     // Safe; as long as we checked
                                     // but harder to read

No entanto, vamos ver esse código quase idêntico:

CMyOtherStuff *pOther;
pOther = static_cast<CMyOtherStuff*>(pSomething); // Compiler error: Can't convert

pOther = (CMyOtherStuff*)(pSomething);            // No compiler error.
                                                  // Same as reinterpret_cast<>
                                                  // and it's wrong!!!

Como você pode ver, não há uma maneira fácil de distinguir entre as duas situações sem saber muito sobre todas as classes envolvidas.

O segundo problema é que as projeções no estilo C são muito difíceis de localizar. Em expressões complexas, pode ser muito difícil visualizar projeções no estilo C. É praticamente impossível escrever uma ferramenta automatizada que precise localizar conversões no estilo C (por exemplo, uma ferramenta de pesquisa) sem um front-end completo do compilador C ++. Por outro lado, é fácil procurar por "static_cast <" ou "reinterpret_cast <".

pOther = reinterpret_cast<CMyOtherStuff*>(pSomething);
      // No compiler error.
      // but the presence of a reinterpret_cast<> is 
      // like a Siren with Red Flashing Lights in your code.
      // The mere typing of it should cause you to feel VERY uncomfortable.

Isso significa que, não apenas os lançamentos no estilo C são mais perigosos, mas é muito mais difícil encontrá-los para garantir que eles estejam corretos.

Uma dica pragmática: você pode pesquisar facilmente a palavra-chave static_cast no seu código-fonte se planeja arrumar o projeto.

Em resumo :

1. static_cast<>() dá a você a capacidade de verificar o tempo de compilação, o elenco do estilo C não.
2. static_cast<>()pode ser visto facilmente em qualquer lugar dentro de um código fonte C ++; em contraste, o elenco de C_Style é mais difícil de detectar.
3. As intenções são transmitidas muito melhor usando conversões de C ++.

Mais explicações :

A conversão estática realiza conversões entre tipos compatíveis . É semelhante ao elenco do estilo C, mas é mais restritivo. Por exemplo, a conversão no estilo C permitiria que um ponteiro inteiro aponte para um caractere.

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

Como isso resulta em um ponteiro de 4 bytes apontando para 1 byte de memória alocada, a gravação nesse ponteiro causará um erro em tempo de execução ou substituirá parte da memória adjacente.

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

Ao contrário da conversão em estilo C, a conversão estática permitirá que o compilador verifique se os tipos de dados de ponteiro e ponta são compatíveis, o que permite ao programador capturar essa atribuição incorreta de ponteiro durante a compilação.

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

Leia mais em:
Qual é a diferença entre static_cast <> e conversão de estilo C
e conversão
regular vs. static_cast vs. dynamic_cast

A questão é maior do que apenas usar a conversão wither static_cast ou estilo C, porque há coisas diferentes que acontecem ao usar moldes no estilo C. Os operadores de conversão de C ++ destinam-se a tornar essas operações mais explícitas.

Na superfície, static_cast e estilo C lançam a mesma coisa, por exemplo, ao converter um valor para outro:

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

Ambos convertem o valor inteiro em um dobro. No entanto, ao trabalhar com ponteiros, as coisas ficam mais complicadas. alguns exemplos:

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

Neste exemplo (1) talvez esteja OK porque o objeto apontado por A é realmente uma instância de B. Mas e se você não souber nesse ponto do código o que realmente aponta? (2) talvez perfeitamente legal (você só quer olhar para um byte do número inteiro), mas também pode ser um erro; nesse caso, um erro seria bom, como (3). Os operadores de conversão de C ++ destinam-se a expor esses problemas no código, fornecendo erros em tempo de compilação ou tempo de execução, quando possível.

Portanto, para estrita "conversão de valor", você pode usar static_cast. Se você desejar a conversão polimórfica de ponteiros em tempo de execução, use dynamic_cast. Se você realmente deseja esquecer os tipos, pode usar reintrepret_cast. E para jogar const pela janela, const_cast.

Eles apenas tornam o código mais explícito, para que você saiba o que estava fazendo.

static_castsignifica que você não pode acidentalmente const_castou reinterpret_cast, o que é uma coisa boa.

1. Permite que as transmissões sejam encontradas facilmente em seu código usando grep ou ferramentas semelhantes.
2. Torna explícito o tipo de elenco que você está fazendo e o envolvimento da ajuda do compilador na imposição. Se você deseja eliminar apenas a constância, use o const_cast, o que não permitirá que você faça outros tipos de conversão.
3. As conversões são inerentemente feias - você como programador está anulando como o compilador trataria seu código normalmente. Você está dizendo ao compilador: "Eu sei melhor que você". Sendo esse o caso, faz sentido que a execução de um elenco deva ser uma coisa moderadamente dolorosa e que eles se destacem no seu código, pois são uma provável fonte de problemas.

Consulte Introdução eficaz ao C ++

É sobre quanta segurança de tipo você deseja impor.

Quando você escreve (bar) foo(o que equivale a reinterpret_cast<bar> foose você não forneceu um operador de conversão de tipos), está dizendo ao compilador para ignorar a segurança de tipos e faça o que é solicitado.

Ao escrever, static_cast<bar> foovocê solicita ao compilador que verifique pelo menos se a conversão de tipo faz sentido e, para tipos integrais, insira algum código de conversão.

EDIT 2014-02-26

Escrevi esta resposta há mais de 5 anos e entendi errado. (Ver comentários.) Mas ainda recebe votos!

As conversões de estilo C são fáceis de perder em um bloco de código. As conversões no estilo C ++ não são apenas melhores práticas; eles oferecem um grau muito maior de flexibilidade.

reinterpret_cast permite integrais para conversões de tipo de ponteiro, no entanto, pode ser inseguro se mal utilizado.

static_cast oferece uma boa conversão para tipos numéricos, por exemplo, de enums para ints ou ints para floats ou quaisquer tipos de dados dos quais você confia. Ele não executa nenhuma verificação de tempo de execução.

O dynamic_cast, por outro lado, executará essas verificações sinalizando quaisquer atribuições ou conversões ambíguas. Funciona apenas em ponteiros e referências e gera uma sobrecarga.

Existem alguns outros, mas estes são os principais que você encontrará.

static_cast, além de manipular ponteiros para classes, também pode ser usado para realizar conversões explicitamente definidas em classes, bem como para executar conversões padrão entre tipos fundamentais:

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