¿Cuál es la diferencia entre static cast<> y C style casting?

En resumen:

1. static_cast<>() le da una capacidad de comprobación de tiempo de compilación, estilo C el reparto no.
2. static_cast<>() es más legible y se puede ver fácilmente en cualquier lugar dentro de un código fuente de C++, C_Style cast no lo es.
3. Las intenciones se transmiten mucho mejor usando C++ casts.

Más Explicación:

El cast estático realiza conversiones entre tipos compatibles. Es similar al elenco estilo C, pero es más restrictivo. Para por ejemplo, el cast de estilo C permitiría que un puntero entero apunte a un char.

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

Dado que esto resulta en un puntero de 4 bytes ( un puntero al tipo de datos de 4 bytes) apuntando a 1 byte de memoria asignada, escribir en este puntero causará un error en tiempo de ejecución o sobrescribirá alguna memoria adyacente.

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

En contraste con el cast de estilo C, el cast estático permitirá al compilador comprobar que los tipos de datos puntero y puntero son compatibles, lo que permite al programador capturar esta asignación de puntero incorrecta durante la compilación.

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

También puede consultar esta página con más explicaciones sobre los moldes de C++: Haga clic aquí

Ver Una comparación de los operadores de casting de C++ .

Sin embargo, usar la misma sintaxis para una variedad de diferentes operaciones de casting puede hacer que la intención del programador no sea clara.

Además, puede ser difícil encontrar un tipo específico de cast en una base de código grande.

La generalidad del molde de estilo C puede ser exagerada para situaciones en las que todo lo que se necesita es una simple conversión. La capacidad de seleccionar entre varios casting diferentes los operadores de diferentes grados de potencia pueden evitar que los programadores puedan lanzar inadvertidamente a un tipo incorrecto.

struct A {};
struct B : A {};
struct C {}; 

int main()
{
    A* a = new A;    

    int i = 10;

    a = (A*) (&i); // NO ERROR! FAIL!

    //a = static_cast<A*>(&i); ERROR! SMART!

    A* b = new B;

    B* b2 = static_cast<B*>(b); // NO ERROR! SMART!

    C* c = (C*)(b); // NO ERROR! FAIL!

    //C* c = static_cast<C*>(b); ERROR! SMART!
}

static_cast comprueba en tiempo de compilación que la conversión no es entre tipos obviamente incompatibles. Al contrario de dynamic_cast, no se comprueba la compatibilidad de tipos en tiempo de ejecución. Además, static_cast la conversión no es necesariamente segura.

static_cast se utiliza para convertir de puntero a clase base a puntero a clase derivada, o entre tipos nativos, como enum a int o float a int.

El usuario de static_cast debe asegurarse de que la conversión es segura.

El elenco de estilo C no realiza ninguna comprobar, ya sea en la compilación o en tiempo de ejecución.

Dado que hay muchos tipos diferentes de casting, cada uno con una semántica diferente, static_cast le permite decir "Estoy haciendo una conversión legal de un tipo a otro" como de int a double. Un molde simple al estilo C puede significar muchas cosas. ¿Estás haciendo casting arriba / abajo? ¿Estás reinterpretando un puntero?

Un gran post explicando diferentes casts en C / C++, y lo que realmente hace C-style cast: https://anteru.net/blog/2007/12/18/200/index.html

C-Style casting, usando la sintaxis de la variable (type). El peor de todos inventar. Esto intenta hacer los siguientes moldes, en este orden: (ver también estándar de C++, 5.4 expr.cast paragraph 5)

1. const_cast
2. static_cast
3. static_cast seguido de const_cast
4. reinterpret_cast
5. reinterpret_castfollowed by const_cast