Question

我需要将一个应该被视为浮点数的整数转换为其十六进制等效值。

例如：

Float To Hex

1 = 0x3f800000

2 = 0x40000000

12345 = 0x4640e400

它始终是整数，而不是0.5之类的分数。这可以通过内存分配或格式化函数来完成，但是使用它的情况，它没有内存访问权限，也没有API调用。

我尝试了这个想法，但它根本不起作用 http://bytes.com/topic/c/answers/219928-how-convert-float-hex#post886069

Answer 1

下面的函数floatAsUint_s()为任何输入x重新解释32位IEEE-754 float作为unsigned int | x |在[1,2 ¹²⁸）中，或者为零。信息一次从float一位提取，结果unsigned int由这些位在时刻构建一位。如果输入和输出都驻留在处理器寄存器而不是存储器中，则在重新解释过程中不需要额外的存储器。

/* re-interpret IEEE-754 float x, |x| in [1, 2**128) or 0, as unsigned int */
unsigned int floatAsUint_s (float x)
{
    unsigned int i;

    /* extract sign bit, proceed with absolute value */
    i = (((x == 0.0f) ? (1.0f / x) : x) < 0.0f) ? 0x80000000 : 0x00000000;
    x = (((x == 0.0f) ? (1.0f / x) : x) < 0.0f) ? -x : x;
    /* extract exponent, which is positive per specification */
    if (x >= 1.84467441e19f) { x /= 1.84467441e19f; i |= 1 << 29; }
    if (x >= 4.29496730e9f)  { x /= 4.29496730e9f;  i |= 1 << 28; }
    if (x >= 65536.0f)       { x /= 65536.0f;       i |= 1 << 27; }
    if (x >= 256.0f)         { x /= 256.0f;         i |= 1 << 26; }
    if (x >= 16.0f)          { x /= 16.0f;          i |= 1 << 25; }
    if (x >= 4.0f)           { x /= 4.0f;           i |= 1 << 24; }
    if (x >= 2.0f)           { x /= 2.0f;           i |= 1 << 23; }
    i += (x == 0.0f) ? 0 : (127 << 23); // add IEEE-754 specified exponent bias
    /* extract mantissa */
    x = x - 1.0f; // remove hidden bit
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 22; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 21; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 20; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 19; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 18; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 17; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 16; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 15; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 14; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 13; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 12; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 11; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 10; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 <<  9; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 <<  8; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 <<  7; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 <<  6; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 <<  5; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 <<  4; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 <<  3; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 <<  2; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 <<  1; } 
    x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 <<  0; } 
    return i;
}

/* reference implementation */
unsigned int floatAsUint (float a)
{
    unsigned int i;
    unsigned char *ap = (unsigned char *)&a, *ip = (unsigned char*)&i;
    for (unsigned int c = 0; c < sizeof (i); c++) { 
        *ip++ = *ap++;
    }
    return i;
}

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int main (void)
{                          
    unsigned int res, ref;
    float s = -1.0f;
    while (s < 2.0f) {
        float x = 0.0f;
        while (x < 3.40282346e38f) {
            ref = floatAsUint (s * x);
            res = floatAsUint_s (s * x);
            if (ref != res) {
                printf ("error @ % 15.8e: res= %08x ref=%08x\n", x, res, ref);
                exit (EXIT_FAILURE);
            }
            x = (x == 0.0f) ? 1.0f : nextafterf (x, 3.40282346e38f);
        }
        s += 2.0f;
    }
    return EXIT_SUCCESS;
}

问题中对规范的另一种解释如下：给定int x，| x |在[0,2 ²⁴]中，产生x值的IEEE-754单精度编码，存储在uint32_t中。仅使用整数运算进行转换。

正非零整数＆lt; = 2 ²⁴的位模式与IEEE-754 float的尾数（隐藏位恢复）的位模式相同它被转换为，只是适当地转移。因此，我们需要通过向左移位整数来进行归一化，直到其最重要的1位位于隐藏尾数位（位23）的位置。归一化所需的移位数告诉我们2的幂整数的大小。，从而确定浮点数的指数。我们需要记住添加IEEE-754规定的指数偏差，然后将符号，指数和尾数部分组合起来作为最终结果。

下面代码中的函数make_float_s()实现了上述算法。

#include <stdint.h>

/* For |a| in [0,2**24], generate IEEE-754 float encoding with same value */
uint32_t make_float_s (int a)
{
    uint32_t i;
    int e = 0;

    i = (a < 0) ? 0x80000000 : 0x00000000;   // sign bit
    if (a) {
        a = (a < 0) ? -a : a;
        while (a < 0x00800000) {   // normalize mantissa
            e++;
            a = a + a;
        }
        e = 127 + (22 - e); // determine biased exponent
        i += (e << 23) + a; // combine sign, exponent, mantissa
    }
    return i;
}

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>

uint32_t float_as_uint (float a)
{
    uint32_t i;
    memcpy (&i, &a, sizeof(i));
    return i;
}

/* reference function */
uint32_t make_float (int a)
{
    return float_as_uint ((float)a);
}

int main (void)
{
    uint32_t res, ref;
    int a, s;

    a=1; printf("%d encoded as IEEE-754 float: %08x\n", a, make_float_s(a));
    a=2; printf("%d encoded as IEEE-754 float: %08x\n", a, make_float_s(a));
    a=12345; printf("%d encoded as IEEE-754 float: %08x\n", a, make_float_s(a));

    s = -1;
    while (s < 2) {
        a = 0;
        while (a <= 16777216) {
            res = make_float_s (s * a);
            ref = make_float (s * a);
            if (res != ref) {
                printf ("error @ % 7d: res=%08x  ref=%08x\n", s * a, res, ref);
                exit (EXIT_FAILURE);
            }
            a++;
        }
        s += 2;
    }
    return EXIT_SUCCESS;
}

Answer 2

您可以使用union。类似的东西：

union data {
    float f_data;
    char c_data[4];
};

用法：

data d1;
d1.f_data = 12345;

之后d1.c_data包含您需要的十六进制值。

C ++仅使用整数数学将float转换为十六进制

2 个答案: