bits flottants et aliasing strict

Question

J'essaie d'extraire les bits d'un flottant sans invoquer de comportement indéfini. Voici ma première tentative:

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

Si je comprends bien, cela est pas garanti en raison des règles strictes d'aliasing, non? Est-ce que cela fonctionne si vous prenez une étape intermédiaire avec un pointeur de caractère?

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

Ou dois-je extraire moi-même les octets individuels?

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

Bien sûr, cela a l'inconvénient de dépendre de l'endianness, mais je pourrais vivre avec cela.

Le hack de l'union est certainement un comportement indéfini, non?

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

Juste pour être complet, voici une version de référence de foo. Aussi un comportement indéfini, non?

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

Alors, est-il possible d'extraire les bits d'un flotteur (si les deux sont très, bien sûr 32 bits)?

---

EDIT: Et voici la version memcpy proposée par Goz. Étant donné que de nombreux compilateurs ne supportent pas encore static_assert, je l'ai remplacé static_assert avec quelques métaprogrammation modèle:

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

Answer 1

A propos de la seule façon d'éviter vraiment des problèmes est de memcpy. Parce que vous enregistrez une quantité fixe, le compilateur optimisera le nombre. Cela dit, la méthode d'union est très largement supportée.

Answer 2

Si vous voulez vraiment être agnostique sur la taille du flotteur et juste retourner les bits premières, faire quelque chose comme ceci:

void float_to_bytes(char *buffer, float f) { 
    union { 
     float x; 
     char b[sizeof(float)]; 
    }; 

    x = f; 
    memcpy(buffer, b, sizeof(float)); 
} 

Ensuite, appelez-le comme suit:

float a = 12345.6789; 
char buffer[sizeof(float)]; 

float_to_bytes(buffer, a); 

Cette technique produira, bien sûr, une sortie spécifique à l'ordre des octets de votre machine.

Answer 3

Le hack de l'union est définitivement un comportement non défini, non?

Oui et non. Selon la norme, c'est définitivement un comportement indéfini. Mais c'est un truc si commun que GCC et MSVC et autant que je sache, tous les autres compilateurs populaires, garantissent explicitement qu'il est sûr et fonctionnera comme prévu.

Answer 4

Ce qui suit ne viole pas la règle de l'aliasing, parce qu'il n'a pas l'utilisation de différents types lvalues ​​accès partout

template<typename B, typename A> 
B noalias_cast(A a) { 
    union N { 
    A a; 
    B b; 
    N(A a):a(a) { } 
    }; 
    return N(a).b; 
} 

unsigned bar(float x) { 
    return noalias_cast<unsigned>(x); 
}