Najbardziej efektywny zgodny ze standardami sposób reinterpretacji int jako float

Załóżmy, że mam gwarancje, że float to IEEE 754 binary32. Biorąc pod uwagę wzór bitowy, który odpowiada poprawnemu float, przechowywanemu w std::uint32_t, Jak można go ponownie zinterpretować jako float w najbardziej efektywny sposób zgodny ze standardem?

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

Mam kilka sposobów, które wiem/podejrzewam / zakładam, że mają pewne problemy:

1. Via reinterpret_cast,

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

   Lub równoważnie

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

   Który cierpi na problemy z aliasingiem.

2. Przez union,

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

   Który nie jest w rzeczywistości legalny, ponieważ jest dozwolony tylko do odczytu z ostatnio napisanego do członka. Wydaje się jednak, że niektóre Kompilatory (gcc) na to pozwalają.

3. Via std::memcpy,

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

   Które AFAIK jest legalne, ale wywołanie funkcji do kopiowania pojedynczego słowa Wydaje się marnotrawne, choć może zostać zoptymalizowane.

4. Przez reinterpret_cast ing do char* i kopiowanie,

   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;
   }
   

   Które AFAIK jest również legalne, ponieważ char wskaźniki są wyłączone z aliasingu problemy i ręczna pętla kopiowania bajtów zapisuje możliwe wywołanie funkcji. Pętla na pewno zostanie rozwinięta, jednak 4 ewentualnie oddzielne jednobajtowe ładunki / sklepy są niepokojące, nie mam pojęcia, czy jest to optymalne do pojedynczego czterobajtowego ładowania / przechowywania.

4 to najlepsze, co udało mi się wymyślić.

Czy jak na razie mam rację? Czy istnieje lepszy sposób, aby to zrobić, zwłaszcza taki, który zagwarantuje pojedynczy ładunek / magazyn?