float bits und striktes Aliasing

Question

Ich versuche, die Bits aus einem Float zu extrahieren, ohne undefiniertes Verhalten aufzurufen. Hier ist mein erster Versuch:

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

Wie ich es verstehe, ist dies nicht wegen der strengen Aliasing Regeln garantiert arbeiten, nicht wahr? Funktioniert es, wenn ein Zwischenschritt mit einem Zeichenzeiger gemacht wird?

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

Oder muss ich die einzelnen Bytes selbst extrahieren?

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

Natürlich hat dies den Nachteil auf endianness von je, aber ich konnte damit leben.

Der Union Hack ist definitiv undefiniert Verhalten, oder?

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

Nur der Vollständigkeit halber, hier ist eine Referenzversion von foo. Auch undefiniertes Verhalten, oder?

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

So ist es möglich, die Bits von einem Schwimmer zu extrahieren (vorausgesetzt, beide sind 32 Bit breit, natürlich)?

---

EDIT: Und hier ist die memcpy Version wie von Goz vorgeschlagen. Da viele Compiler noch nicht static_assert unterstützen, habe ich static_assert mit etwas Metaprogrammierung ersetzt:

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

Über die einzige Möglichkeit, wirklich alle Probleme zu vermeiden, ist zu MEMCPY.

Da Sie einen festen Betrag speichern, wird der Compiler es optimieren.

Das sagte die Union-Methode ist sehr weit verbreitet.

Answer 2

Wenn Sie wirklich wollen, über die Größe des Schwimmers Typ Agnostiker sein und nur die Rohbits zurückkehren, tun Sie etwas wie folgt aus:

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

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

es dann rufen Sie wie folgt:

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

float_to_bytes(buffer, a); 

Diese Technik erzeugt natürlich eine Ausgabe, die spezifisch für die Bytereihenfolge Ihrer Maschine ist.

Answer 3

Die Union Hack ist definitiv undefiniert Verhalten, oder?

Ja und nein. Gemäß dem Standard ist es definitiv undefiniertes Verhalten. Aber es ist solch ein häufig verwendeter Trick, dass GCC und MSVC und soweit ich weiß, jeder andere populäre Compiler explizit garantiert, dass es sicher ist und wie erwartet funktioniert.

Answer 4

Die folgende nicht die Aliasing-Regel verstoßen, weil es keinen Gebrauch von lvalues ​​Zugriff auf verschiedene Arten überall

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