¿Por qué usar static_cast <int> (x) en lugar de (int) x?

Escuché que la static_castfunción debería preferirse al estilo C o al simple estilo de conversión de funciones. ¿Es esto cierto? ¿Por qué?

La razón principal es que los moldes clásicos C no hacen distinción entre lo que llamamos static_cast<>(), reinterpret_cast<>(), const_cast<>(), y dynamic_cast<>(). Estas cuatro cosas son completamente diferentes.

A static_cast<>()suele ser seguro. Hay una conversión válida en el lenguaje, o un constructor apropiado que lo hace posible. La única vez que es un poco arriesgado es cuando echas abajo a una clase heredada; debes asegurarte de que el objeto sea realmente el descendiente que afirmas que es, por medios externos al lenguaje (como una bandera en el objeto). A dynamic_cast<>()es seguro siempre que se verifique el resultado (puntero) o se tenga en cuenta una posible excepción (referencia).

A reinterpret_cast<>()(o a const_cast<>()) por otro lado siempre es peligroso. Le dice al compilador: "confía en mí: sé que esto no se parece a un foo(parece que no es mutable), pero lo es".

El primer problema es que es casi imposible saber cuál ocurrirá en un reparto de estilo C sin mirar piezas de código grandes y dispersas y sin conocer todas las reglas.

Asumamos esto:

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

CMyBase  *pSomething; // filled somewhere

Ahora, estos dos se compilan de la misma manera:

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

Sin embargo, veamos este código casi 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 puede ver, no hay una manera fácil de distinguir entre las dos situaciones sin saber mucho sobre todas las clases involucradas.

El segundo problema es que los modelos de estilo C son demasiado difíciles de localizar. En expresiones complejas puede ser muy difícil ver modelos de estilo C. Es prácticamente imposible escribir una herramienta automatizada que necesite localizar modelos de estilo C (por ejemplo, una herramienta de búsqueda) sin un compilador de C ++ completo. Por otro lado, es fácil buscar "static_cast <" o "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.

Eso significa que, no solo los lanzamientos de estilo C son más peligrosos, sino que es mucho más difícil encontrarlos a todos para asegurarse de que sean correctos.

Un consejo pragmático: puede buscar fácilmente la palabra clave static_cast en su código fuente si planea ordenar el proyecto.

En resumen :

1. static_cast<>() le da una capacidad de comprobación de tiempo de compilación, el elenco de C-Style no.
2. static_cast<>()se puede detectar fácilmente en cualquier lugar dentro de un código fuente de C ++; en contraste, el molde C_Style es más difícil de detectar.
3. Las intenciones se transmiten mucho mejor usando moldes C ++.

Más explicaciones :

La conversión estática realiza conversiones entre tipos compatibles . Es similar al elenco de estilo C, pero es más restrictivo. Por ejemplo, el reparto de estilo C permitiría que un puntero entero apunte a un carácter.

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

Dado que esto da como resultado un puntero de 4 bytes que apunta a 1 byte de memoria asignada, escribir en este puntero provocará un error de tiempo de ejecución o sobrescribirá alguna memoria adyacente.

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

A diferencia de la conversión de estilo C, la conversión estática permitirá que el compilador verifique que los tipos de datos de puntero y puntero sean compatibles, lo que permite al programador detectar esta asignación de puntero incorrecta durante la compilación.

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

Lea más sobre:
¿Cuál es la diferencia entre static_cast <> y C estilo casting
y
Regular cast vs. static_cast vs. dynamic_cast

La pregunta es más grande que simplemente usar wither static_cast o el estilo C porque hay diferentes cosas que suceden cuando se usan los moldes de estilo C. Los operadores de conversión de C ++ están destinados a hacer estas operaciones más explícitas.

En la superficie, las conversiones de estilo static_cast y C aparecen de la misma manera, por ejemplo, al convertir un valor a otro:

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

Ambos arrojan el valor entero a un doble. Sin embargo, cuando se trabaja con punteros, las cosas se vuelven más complicadas. algunos ejemplos:

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

En este ejemplo (1) tal vez está bien porque el objeto señalado por A es realmente una instancia de B. Pero, ¿qué sucede si en ese punto del código no sabe a qué apunta realmente? (2) puede ser perfectamente legal (solo desea mirar un byte del entero), pero también podría ser un error en cuyo caso un error sería bueno, como (3). Los operadores de conversión de C ++ están destinados a exponer estos problemas en el código al proporcionar errores en tiempo de compilación o tiempo de ejecución cuando sea posible.

Por lo tanto, para una "conversión de valor" estricta, puede usar static_cast. Si desea la conversión polimórfica de punteros en tiempo de ejecución, use dynamic_cast. Si realmente quiere olvidarse de los tipos, puede usar reintrepret_cast. Y para lanzar const por la ventana hay const_cast.

Simplemente hacen que el código sea más explícito para que parezca que sabes lo que estabas haciendo.

static_castsignifica que no puedes accidentalmente const_casto reinterpret_cast, lo cual es algo bueno.

1. Permite que los moldes se encuentren fácilmente en su código utilizando grep o herramientas similares.
2. Hace explícito qué tipo de elenco estás haciendo, y solicita la ayuda del compilador para aplicarlo. Si solo desea deshacerse de la constante, puede usar const_cast, que no le permitirá realizar otros tipos de conversiones.
3. Los casts son inherentemente feos: usted, como programador, está anulando cómo el compilador trataría su código normalmente. Le estás diciendo al compilador: "Sé mejor que tú". Siendo ese el caso, tiene sentido que realizar un reparto sea algo moderadamente doloroso y que se destaque en su código, ya que son una fuente probable de problemas.

Ver introducción efectiva de C ++

Se trata de cuánta seguridad de tipografía desea imponer.

Cuando escribe (bar) foo(que es equivalente a reinterpret_cast<bar> foosi no ha proporcionado un operador de conversión de tipo) le está diciendo al compilador que ignore la seguridad de tipo, y simplemente haga lo que se le dice.

Cuando escribe, static_cast<bar> foole está pidiendo al compilador que al menos verifique que la conversión de tipos tenga sentido y, para los tipos integrales, que inserte algún código de conversión.

EDITAR 2014-02-26

Escribí esta respuesta hace más de 5 años, y me equivoqué. (Véanse los comentarios.) ¡Pero todavía recibe votos positivos!

Los moldes de estilo C son fáciles de perder en un bloque de código. Los modelos de estilo C ++ no solo son una mejor práctica; Ofrecen un mayor grado de flexibilidad.

reinterpret_cast permite conversiones de tipo integral a puntero, sin embargo, puede ser inseguro si se usa incorrectamente.

static_cast ofrece una buena conversión para tipos numéricos, por ejemplo, desde enumeraciones a entradas o entradas a flotantes o cualquier tipo de datos de los que tenga confianza. No realiza ninguna comprobación de tiempo de ejecución.

Dynamic_cast, por otro lado, realizará estas comprobaciones marcando cualquier asignación o conversión ambigua. Solo funciona en punteros y referencias e incurre en una sobrecarga.

Hay un par de otros, pero estos son los principales con los que te encontrarás.

static_cast, además de manipular punteros a clases, también se puede usar para realizar conversiones definidas explícitamente en clases, así como para realizar conversiones estándar entre tipos fundamentales:

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