¿Cuál es el equivalente en C de reinterpret_cast?

¿Cuál es el equivalente de C para el reinterpret_cast de C ++?

 int *foo; float *bar; // c++ style: foo = reinterpret_cast< int * >(bar); // c style: foo = (int *)(bar); 

Los modelos de estilo C solo se ven como nombres de tipo entre paréntesis:

 void *p = NULL; int i = (int)p; // now i is most likely 0 

Obviamente, hay mejores usos para los modelos que esto, pero esa es la syntax básica.

No existe, porque reinterpret_cast no puede cambiar [constness] [3]. Por ejemplo,

 int main() { const unsigned int d = 5; int *g=reinterpret_cast< int* >( &d ); (void)g; } 

producirá el error:

dk.cpp: en la función ‘int main ()’:
dk.cpp: 5: 41: error: reinterpret_cast del tipo ‘const unsigned int *’ al tipo ‘int *’ desecha los calificadores

Un reparto de estilo C es:

 int* two = ...; pointerToOne* one = (pointerToOne*)two; 

Si puede tomar la dirección del valor, una forma es convertir un puntero a un puntero a un tipo diferente y luego eliminar la referencia del puntero.

Por ejemplo, una conversión float-to-int:

 int main() { float f = 1.0f; printf ("f is %f\n", f); printf ("(int) f is %d\n", (int)f); printf ("f as an unsigned int:%x\n", *(unsigned int *)&f); } 

Salida:

 f is 1.000000 (int) f is 1 f as an unsigned int:3f800000 

Tenga en cuenta que esto probablemente no está garantizado para funcionar según el estándar C. No se puede usar reinterpret_cast para convertir de float a int de todos modos, pero sería similar para un tipo que fue compatible (por ejemplo, entre diferentes tipos de punteros).

Confirmemos que la salida de arriba tiene sentido, de todos modos.

http://en.wikipedia.org/wiki/Single_precision_floating-point_format#IEEE_754_single-precision_binary_floating-point_format:_binary32

La última respuesta en binario:

0011 1111 1000 0000 0000 0000 0000 0000

Este es el formato de punto flotante IEEE-754: un bit de signo de 0, seguido de un exponente de 8 bits (011 1111 1), seguido de una mantisa de 23 bits (todos ceros).

Para interpretar el exponente, reste 127: 01111111b = 127, y 127 – 127 = 0. El exponente es 0.

Para interpretar la mantisa, escríbala después de 1 seguido de un punto decimal: 1.00000000000000000000000 (23 ceros). Esto es 1 en decimal.

Por lo tanto, el valor representado por hexadecimal 3f800000 es 1 * 2 ^ 0 = 1, como esperábamos.

Puede lanzar libremente tipos de puntero en C como lo haría con cualquier otro tipo.

Estar Completo:

 void *foo; some_custom_t *bar; other_custom_t *baz; /* Initialization... */ foo = (void *)bar; bar = (some_custom_t *)baz; baz = (other_custom_t *)foo; 

¿Qué pasa con un operador REINTERPRET para c:

 #define REINTERPRET(new_type, var) ( * ( (new_type *) & var ) ) 

No me gusta decir “reinterpret_cast”, porque cast significa conversión (en c), mientras que reinterpretar significa lo contrario: no hay conversión.