Convirtiendo doble a vacío* en C

2 minutos de lectura

Estoy escribiendo un intérprete y me gustaría poder almacenar cualquier valor que devuelva una función en un puntero vacío. No he tenido problemas para almacenar ints y varios punteros como punteros nulos, pero recibo un error cuando intento convertir un doble como puntero nulo. Entiendo que los dobles se almacenan de manera diferente que los enteros y los punteros a nivel de bits, pero no entiendo por qué no puedo colocar los bits que quiero en el puntero (suponiendo que tenga suficiente memoria asignada) y luego sacarlos más tarde, echándolos como un doble.

¿Es posible lanzar un puntero doble a un vacío utilizando una sintaxis que no conozco o no entiendo cómo funcionan los punteros vacíos?

  • ¿Has considerado usar un union en lugar de ?

    – André Holzner

    4 de julio de 2011 a las 19:27

  • Parece que estás haciendo algo terriblemente mal. Por favor, mira la respuesta de David.

    – pmr

    4 de julio de 2011 a las 19:31

  • revisa mi respuesta en esta otra pregunta stackoverflow.com/questions/6539023/…

    – Vinicius Kamakura

    4 de julio de 2011 a las 19:32

Convirtiendo doble a vacio en C
David Heffernan

En muchos sistemas un double tiene 8 bytes de ancho y un puntero tiene 4 bytes de ancho. El primero, por tanto, no encajaría en el segundo.

Parece que estás abusando void*. Su solución implicará la asignación de espacio de almacenamiento al menos tan grande como el tipo más grande que necesita almacenar en alguna estructura similar a una variante, por ejemplo, un union.

  • No puedo creer que nunca haya oído hablar de un sindicato antes. Esto es exactamente lo que estaba buscando.

    – Jack

    4 de julio de 2011 a las 19:41

Por supuesto que es posible lanzarlo. Los punteros vacíos son lo que hace posible el polimorfismo en C. Debe saber de antemano qué está pasando a su función.

void *p_v ;
double *p_d ;
p_d = malloc( sizeof( double ) ) ;
p_v = ( void * ) p_d ;

  • Su ejemplo parece funcionar porque p_d es un puntero. El operador estaba preguntando acerca de una conversión sin puntero a void*.

    usuario2074102

    3 de marzo de 2016 a las 20:06

Convirtiendo doble a vacio en C
cpuwolf

Sigue con Fabio. y asegúrese de que está ejecutando en x64

int main()
{
    double d = 1.00e+00; // 0x3ff0000000000000
    double* pd = &d;
    void** p = (void**)pd;
    void* dp = *p;
    printf("%f %p %p %p \n", d, pd, p, dp);

    printf("%d %f\n", dp, *(double*)p);

    printf("%f\n", *(double*)(void **)&d);
}

producción

1.000000 0000000353F1FA30 0000000353F1FA30 3FF0000000000000
0 1.000000
1.000000

Aquí es

int main ( ) {
    double d = 1.00e+00 ; // 0x3ff0000000000000
    double * pd = & d ;
    void * * p = ( void * * ) pd ;
    void * dp = * p ;
    printf ( "%f %p %p %p \n" , d , pd , p , dp ) ;
    return 0 ;
} ;

producción

1.000000 0x7fff89a7de80 0x7fff89a7de80 0x3ff0000000000000

La segunda y la tercera dirección pueden ser diferentes. Un atajo

void * dp = * ( void * * ) & d ;

Salud

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad