将 int 重新解释为 float 的最有效的标准兼容方式

Question

假设我保证 float 是 IEEE 754 binary32。给定一个对应于有效浮点数的位模式，存储在std::uint32_t 中，如何以最有效的标准兼容方式将其重新解释为float？

float reinterpret_as_float(std::uint32_t ui) {
   return /* apply sorcery to ui */;
}

我有几种方法我知道/怀疑/假设有一些问题：

1. 通过reinterpret_cast，

   float reinterpret_as_float(std::uint32_t ui) {
       return reinterpret_cast<float&>(ui);
   }
   

   或等效

   float reinterpret_as_float(std::uint32_t ui) {
       return *reinterpret_cast<float*>(&ui);
   }
   

   存在别名问题。

2. 通过union，

   float reinterpret_as_float(std::uint32_t ui) {
       union {
           std::uint32_t ui;
           float f;
       } u = {ui};
       return u.f;
   }
   

   这实际上是不合法的，因为它只允许从最近写给成员的内容中读取。然而，似乎有些编译器 (gcc) 允许这样做。

3. 通过std::memcpy，

   float reinterpret_as_float(std::uint32_t ui) {
       float f;
       std::memcpy(&f, &ui, 4);
       return f;
   }
   

   哪个 AFAIK 是合法的，但是复制单个单词的函数调用似乎很浪费，尽管它可能会被优化掉。

4. 通过reinterpret_casting 到char* 并复制，

   float reinterpret_as_float(std::uint32_t ui) {
       char* uip = reinterpret_cast<char*>(&ui);
       float f;
       char* fp = reinterpret_cast<char*>(&f);
       for (int i = 0; i < 4; ++i) {
           fp[i] = uip[i];
       }
       return f;
   }
   

   哪个 AFAIK 也是合法的，因为 char 指针不受别名问题的影响，并且手动字节复制循环节省了可能的函数调用。循环肯定会被展开，但是 4 个可能单独的一字节加载/存储令人担忧，我不知道这是否可优化为单个四字节加载/存储。

4 是我能想到的最好的。

到目前为止我是对的吗？有没有更好的方法来做到这一点，特别是可以保证单次加载/存储的方法？

Answer 1

Afaik，只有两种方法符合严格的别名规则：memcpy() 和通过复制转换为 char*。所有其他人从属于uint32_t 的内存中读取float，并且允许编译器在写入该内存位置之前执行读取。它甚至可以完全优化写入，因为它可以证明根据严格的别名规则永远不会使用存储的值，从而导致垃圾返回值。

这真的取决于编译器/优化 memcpy() 或 char* 复制是否更快。在这两种情况下，智能编译器可能会发现它可以加载和复制 uint32_t，但在我在生成的汇编代码中看到它之前，我不相信任何编译器会这样做。

编辑：
在使用 gcc 4.8.1 进行一些测试后，我可以说 memcpy() 方法是这个特定编译器的最佳选择，详情请参见下文。

---

编译

#include <stdint.h>

float foo(uint32_t a) {
    float b;
    char* aPointer = (char*)&a, *bPointer = (char*)&b;
    for( int i = sizeof(a); i--; ) bPointer[i] = aPointer[i];
    return b;
}

使用gcc -S -std=gnu11 -O3 foo.c 会产生以下汇编代码：

movl    %edi, %ecx
movl    %edi, %edx
movl    %edi, %eax
shrl    $24, %ecx
shrl    $16, %edx
shrw    $8, %ax
movb    %cl, -1(%rsp)
movb    %dl, -2(%rsp)
movb    %al, -3(%rsp)
movb    %dil, -4(%rsp)
movss   -4(%rsp), %xmm0
ret

这不是最优的。

对

做同样的事情

#include <stdint.h>
#include <string.h>

float foo(uint32_t a) {
    float b;
    char* aPointer = (char*)&a, *bPointer = (char*)&b;
    memcpy(bPointer, aPointer, sizeof(a));
    return b;
}

产量（除-O0 之外的所有优化级别）：

movl    %edi, -4(%rsp)
movss   -4(%rsp), %xmm0
ret

这是最佳选择。

Answer 2

如果整数变量中的位模式与有效的float 值相同，那么联合可能是最好的和最合规的方法。如果您阅读规范，这实际上是合法的（暂时不记得该部分）。

Answer 3

memcpy 总是安全的，但确实涉及副本

强制转换可能会导致问题

联合 - 在 C99 和 C11 中似乎是允许的，不确定 C++

看看：

What is the strict aliasing rule?

和

Is type-punning through a union unspecified in C99, and has it become specified in C11?

Answer 4

float reinterpret_as_float(std::uint32_t ui) {
   return *((float *)&ui);
}

作为普通函数，它的代码被翻译成这样的程序集（Pelles C for Windows）：

fld [esp+4]
ret

如果定义为inline 函数，那么这样的代码（n 为无符号，x 为浮点数）：

x = reinterpret_as_float (n);

被翻译成汇编器是这样的：

fld [ebp-4]  ;RHS of asignment. Read n as float
fstp dword ptr [ebp-8]  ;LHS of asignment