Debo usar static_cast o reinterpret_cast al emitir un vacío * a lo que sea

Question

Tanto static_cast como reinterpret_cast parecen funcionar bien para emitir void * a otro tipo de puntero. ¿Hay una buena razón para favorecer a uno sobre el otro?

Answer 1

Use static_cast: es el modelo más estrecho que describe exactamente qué conversión se realiza aquí.

Existe la idea errónea de que usar reinterpret_cast sería una mejor coincidencia porque significa "ignorar por completo la seguridad de tipo y simplemente enviar de A a B". Sin embargo, esto no describe el efecto de reinterpret_cast. Más bien, reinterpret_cast tiene una serie de significados, para todos los cuales sostiene que “la asignación realizada por reinterpret_cast es definido por la implementación.” [5.2.10.3]

Pero en el caso particular de fundición de void* a T* el mapeo es completamente bien definido por el estándar; a saber, para asignar un tipo a un puntero sin tipo sin cambiar su dirección.

Esta es una razón para preferir static_cast.

Además, y posiblemente más importante, es el hecho de que cada uso de reinterpret_cast es muy peligroso ya que convierte cualquier cosa a cualquier otra cosa realmente (para los punteros), mientras que static_cast es mucho más restrictiva, lo que proporciona un mayor nivel de protección. Esto ya me ha salvado de errores donde accidentalmente intenté forzar un tipo de puntero a otro.

Answer 2

Esta es una pregunta difícil. Por un lado, Konrad hace una excelente observación sobre la definición de la especificación reinterpret_cast, aunque en la práctica probablemente haga lo mismo. Por otro lado, si está alternando entre tipos de punteros (como es bastante común al indexar en la memoria a través de un char *, por ejemplo), static_cast generará un error de compilación y se le forzará a usar reinterpret_cast de todas formas.

En la práctica uso reinterpret_cast porque es más descriptivo de la intención de la operación de conversión. Ciertamente se podría hacer un caso para que un operador diferente designe únicamente reinterpretadores de punteros (lo que garantiza que se devuelva la misma dirección), pero no hay ninguno en el estándar.

Answer 3

Mi preferencia personal se basa en la alfabetización código como este:

void* data = something; 
MyClass* foo = reinterpret_cast<MyClass*>(data); 
foo->bar(); 

o

typedef void* hMyClass; //typedef as a handle or reference 
hMyClass = something; 
const MyClass& foo = static_cast<MyClass&>(*hMyClass); 
foo.bar(); 

Ambos hacen lo mismo en el final, pero static_cast parece más apropiado en un medio-ware, entorno de la aplicación, mientras que reinterpretar el elenco parece más como algo que verías en una biblioteca de nivel inferior en mi humilde opinión.

Answer 4

Sugiero usar el modelo más débil posible siempre.

reinterpret_cast se puede utilizar para lanzar un puntero a un flotador. Cuanto más elemental es el reparto de estructuras, más atención requiere su uso.

En el caso de char *, utilizaría el moldeado c-style, hasta que tengamos un reinterpret_pointer_cast, porque es más débil y nada más es suficiente.