浮点位和严格的别名

2022-01-09 00:00:00 floating-point bits c++ type-punning strict-aliasing

我试图在不调用未定义行为的情况下从浮点数中提取位.这是我的第一次尝试:

I am trying to extract the bits from a float without invoking undefined behavior. Here is my first attempt:

unsigned foo(float x)
{
    unsigned* u = (unsigned*)&x;
    return *u;
}

据我了解，由于严格的别名规则，这不能保证有效，对吧?如果使用字符指针进行中间步骤，它是否有效?

As I understand it, this is not guaranteed to work due to strict aliasing rules, right? Does it work if a take an intermediate step with a character pointer?

unsigned bar(float x)
{
    char* c = (char*)&x;
    unsigned* u = (unsigned*)c;
    return *u;
}

还是我必须自己提取单个字节?

Or do I have to extract the individual bytes myself?

unsigned baz(float x)
{
    unsigned char* c = (unsigned char*)&x;
    return c[0] | c[1] << 8 | c[2] << 16 | c[3] << 24;
}

当然，这有依赖字节序的缺点，但我可以忍受.

Of course this has the disadvantage of depending on endianness, but I could live with that.

union hack 绝对是未定义的行为，对吧?

The union hack is definitely undefined behavior, right?

unsigned uni(float x)
{
    union { float f; unsigned u; };
    f = x;
    return u;
}

为了完整起见，这里是 foo 的参考版本.也是未定义的行为，对吧?

Just for completeness, here is a reference version of foo. Also undefined behavior, right?

unsigned ref(float x)
{
    return (unsigned&)x;
}

那么，是否可以从浮点数中提取位(当然，假设两者都是 32 位宽)?

So, is it possible to extract the bits from a float (assuming both are 32 bits wide, of course)?

这里是 Goz 提出的 memcpy 版本.由于许多编译器还不支持 static_assert，我已将 static_assert 替换为一些模板元编程:

And here is the memcpy version as proposed by Goz. Since many compilers do not support static_assert yet, I have replaced static_assert with some template metaprogramming:

template <bool, typename T>
struct requirement;

template <typename T>
struct requirement<true, T>
{
    typedef T type;
};

unsigned bits(float x)
{
    requirement<sizeof(unsigned)==sizeof(float), unsigned>::type u;
    memcpy(&u, &x, sizeof u);
    return u;
}

推荐答案

关于真正避免任何问题的唯一方法是 memcpy.

About the only way to truly avoid any issues is to memcpy.

unsigned int FloatToInt( float f )
{
   static_assert( sizeof( float ) == sizeof( unsigned int ), "Sizes must match" );
   unsigned int ret;
   memcpy( &ret, &f, sizeof( float ) );
   return ret;
}

因为你内存在一个固定的数量，编译器会优化它.

Because you are memcpying a fixed amount the compiler will optimise it out.

也就是说联合方法得到了非常广泛的支持.

That said the union method is VERY widely supported.

相关文章