La manière la plus efficace de réinterpréter int en tant que flotteur

supposons que j'ai des garanties que float est IEEE 754 binary32. Étant donné un patron de bits qui correspond à un flotteur valide, stocké dans std::uint32_t , comment peut-on le réinterpréter comme un float d'une manière conforme standard la plus efficace?

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

j'ai quelques moyens que je sais / suspecte/suppose ont quelques problèmes:

1. Via reinterpret_cast ,

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

   ou l'équivalent

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

   qui souffre de problèmes d'alias.

2. Via union ,

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

   qui n'est pas réellement légal, car il est seulement permis de lire à partir de la plus récente écrit à un membre. Pourtant, il semble que certains compilateurs (gcc).

3. Via std::memcpy ,

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

   ce qui AFAIK est légal, mais un appel de fonction pour copier le mot simple semble inutile, bien qu'il puisse obtenir optimisé loin.

4. Via reinterpret_cast ing char* et la copie,

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

   qui AFAIK est également légal, comme char pointeurs sont exemptés de problèmes d'aliasing et manuel byte copie boucle enregistre un appel de fonction possible. La boucle sera très certainement déroulée, mais 4 charges d'un octet éventuellement séparées / les magasins sont inquiétants, Je n'ai pas idée si cela est optimisable à quatre byte simple de charge / de stockage.

le 4 est le meilleur que j'ai pu trouver.

ai-je raison jusqu'à présent? Y a-t-il une meilleure façon de le faire, en particulier une façon qui garantira un seul chargement/stockage?