IEEE 754 del flotador a hexadecimal con c - printf

Question

Lo ideal sería el siguiente código tomaría un flotador en la representación IEEE 754 y convertirlo en hexadecimal

void convert() //gets the float input from user and turns it into hexadecimal 
{ 
    float f; 
    printf("Enter float: "); 
    scanf("%f", &f); 
    printf("hex is %x", f); 
} 

No estoy muy seguro de lo que va mal. Está convirtiendo el número en un número hexadecimal, pero uno muy equivocado.

123.1443 gives 40000000 
43.3  gives 60000000 
8  gives 0 

por lo que está haciendo algo, no estoy muy seguro de qué.

ayuda se agradece

Answer 1

Cuando se pasa una float como argumento a una función variadic (como printf()), se promueve a un double, que es dos veces tan grande como una float (por lo menos en la mayoría de las plataformas)

Una forma de evitar esto sería a emitir el float a un unsigned int cuando se pasa como argumento a printf():

printf("hex is %x", *(unsigned int*)&f); 

Esto también es más correcto, ya que printf() utiliza los especificadores de formato para determinar cómo grande cada argumento es

Técnicamente, esta solución infringe el strict aliasing rule. Se puede evitar esto mediante la copia de los bytes de la float en un unsigned int y luego pasa que a printf():

unsigned int ui; 
memcpy(&ui, &f, sizeof (ui)); 

printf("hex is %x", ui); 

Ambas soluciones se basan en la suposición de que sizeof(int) == sizeof(float), que es el caso en muchos de 32 bits sistemas, pero no es necesariamente el caso.

Answer 2

Cuando se admite, use% a para convertir el punto flotante a un formato hexadecimal estándar. Aquí está el único document que pude encontrar que enumeró la opción% a.

De lo contrario, debe extraer los bits del valor del punto flotante en un tipo entero de tamaño conocido. Si usted sabe, por ejemplo, que tanto flotador y int son de 32 bits, se puede hacer un reparto rápido:

printf("%08X" , *(unsigned int*)&aFloat); 

Si quieres ser menos dependientes de tamaño, puede utilizar una unión:

union { 
    float f; 
//char c[16]; // make this large enough for any floating point value 
    char c[sizeof(float)]; // Edit: changed to this 
} u; 

u.f = aFloat; 
for (i = 0 ; i < sizeof(float) ; ++i) printf("%02X" , u.c[i] & 0x00FF); 

El orden del ciclo dependería de la arquitectura endianness. Este ejemplo es Big Endian.

De cualquier forma, el formato de punto flotante puede no ser portátil para otras arquitecturas. La opción% a está destinada a ser.

Answer 3

¿Qué tal esto?

int main(void){ 
    float f = 28834.38282; 
    char *x = (char *)&f; 
    printf("%f = ", f); 

    for(i=0; i<sizeof(float); i++){ 
    printf("%02X ", *x++ & 0x0000FF); 
    } 

    printf("\n"); 
} 

Answer 4

HEX flotar

que pasan mucho tiempo tratando de encontrar la manera de convertir una entrada de HEX de una conexión en serie con formato de IEE754 flotador en flotador. Ahora lo tengo. Solo quería compartir en caso de que pudiera ayudar a alguien más.

#include <stdio.h> 
#include <stdlib.h> 
int main(int argc, char *argv[]) 
{ 

    uint16_t tab_reg[64]     //declare input value recieved from serial connection 
    union IntFloat { int32_t i; float f; }; //Declare combined datatype for HEX to FLOAT conversion 
    union IntFloat val;      
    int i; 
    char buff[50];       //Declare buffer for string 

    i=0; 

    //tab_reg[i]=0x508C;     //to test the code without a data stream, 
    //tab_reg[i+1]=0x4369;     //you may uncomment these two lines. 


    printf("Raw1: %X\n",tab_reg[i]);  //Print raw input values for debug 
    printf("Raw2: %X\n",tab_reg[i+1]);  //Print raw input values for debug 

    rs = sprintf(buff,"0X%X%X", tab_reg[i+1], tab_reg[i]); //I need to swap the words, as the response is with the opposite endianness. 
    printf("HEX: %s",buff);     //Show the word-swapped string 
    val.i = atof(buff);      //Convert string to float :-) 
    printf("\nFloat: %f\n", val.f);   //show the value in float 

} 

Salida:

Raw1: 508C 
Raw2: 436A 
HEX: 0X436A508C 
Float: 234.314636 

Answer 5

Este enfoque siempre funcionó bastante bien para mí:

union converter{ 
float f_val; 
unsigned int u_val; 
}; 

union converter a; 
a.f_val = 123.1443f; 
printf("my hex value %x \n", a.u_val); 

Answer 6

ejemplo Estúpidamente simple:

unsigned char* floatToHex(float val){ 
    unsigned char* hexVals = malloc(sizeof(float)); 
    hexVals[0] = ((unsigned char*)&val)[0]; 
    hexVals[1] = ((unsigned char*)&val)[1]; 
    hexVals[2] = ((unsigned char*)&val)[2]; 
    hexVals[3] = ((unsigned char*)&val)[3]; 
    return hexVals; 
} 

solución Bastante obvio cuando me di cuenta que fuera. Sin enmascaramiento, memcpy u otros trucos necesarios.

En el ejemplo anterior, era para un propósito específico y sabía que las carrozas eran de 32 bits. Una mejor solución si no está seguro del sistema:

unsigned char* floatToHex(float val){ 
    unsigned char* hexVals = malloc(sizeof(float)); 
    for(int i = 0; i < sizeof(float); i++){ 
     hexVals[i] = ((unsigned char*)&val)[i]; 
    } 
    return hexVals; 
} 

Answer 7

Lo que finalmente trabajó para mí (enrevesado como parece):

#include <stdio.h> 
int main((int argc, char** argv) 
{ 
    float flt = 1234.56789; 
    FILE *fout; 
    fout = fopen("outFileName.txt","w"); 
    fprintf(fout, "%08x\n", *((unsigned long *)&flt); 
     /* or */ 
    printf("%08x\n", *((unsigned long *)&flt); 
} 

Answer 8

https://github.com/aliemresk/ConvertD2H/blob/master/main.c

Convertir Hex para doblar Convierte Doble Hexagonal

estos códigos funcionan en formato flotante IEEE 754.