Aufbau einer 32-bit-float-out der 4 composite bytes

Ich versuche zu bauen, ein 32-bit-float-out der 4 composite-bytes. Gibt es eine bessere (oder mehr tragbare) Weg, dies zu tun, als mit der folgenden Methode?

#include <iostream>

typedef unsigned char uchar;

float bytesToFloat(uchar b0, uchar b1, uchar b2, uchar b3)
{
    float output;

    *((uchar*)(&output) + 3) = b0;
    *((uchar*)(&output) + 2) = b1;
    *((uchar*)(&output) + 1) = b2;
    *((uchar*)(&output) + 0) = b3;

    return output;
}

int main()
{
    std::cout << bytesToFloat(0x3e, 0xaa, 0xaa, 0xab) << std::endl; //1.0 /3.0
    std::cout << bytesToFloat(0x7f, 0x7f, 0xff, 0xff) << std::endl; //3.4028234 × 10^38  (max single precision)

    return 0;
}

Wenn man bedenkt, dass dies war meine erste Frage auf Stack Overflow, ich bin begeistert, auf den verschiedenen Antworten. Ich danke allen für Ihren input.

InformationsquelleAutor Madgeek | 2010-10-21

c++endianness floating-point portability single-precision

29

Könnte man eine memcpy (Ergebnis)
```
float f;
uchar b[] = {b3, b2, b1, b0};
memcpy(&f, &b, sizeof(f));
return f;
```
oder eine union* (Ergebnis)
```
union {
  float f;
  uchar b[4];
} u;
u.b[3] = b0;
u.b[2] = b1;
u.b[1] = b2;
u.b[0] = b3;
return u.f;
```
Aber dies ist nicht mehr tragbar als Sie Ihren code, da es keine Garantie dafür, dass die Plattform little-endian-oder die float ist mit IEEE binary32 oder sogar sizeof(float) == 4.

(Anmerkung*: Wie bereits erläutert durch @James, ist es technisch nicht erlaubt in der standard-C++ §[Klasse.union]/1) Zugriff auf das union-Mitglied u.f.)
- Zum lösen der sizeof(float) problem, können Sie einfach erklären, die b Mitglied als uchar b[sizeof(float)];.
- Richtig, aber dann wird der Eingang muss modifiziert werden, wie gut.
- Die union-Methode führt zu undefiniertem Verhalten.
InformationsquelleAutor kennytm

Folgende Funktionen packen/entpacken bytes zur Darstellung eines single-precision floating-point-Wert zu/von einem Pufferspeicher in network-byte-order. Nur der pack-Methode nehmen muss, endianness zu berücksichtigen, da die unpack-Methode explizit Konstrukte der 32-bit-Wert aus den einzelnen bytes durch bit-shifting Ihnen den entsprechenden Betrag und dann eine logische ODER-Funktion zusammen. Diese Funktionen gelten nur für C/C++ - Implementierungen zu speichern, dass ein Schwimmer in 32-bit. Dies gilt für IEEE 754-1985 Gleitkomma-Implementierungen.

//unpack method for retrieving data in network byte,
//  big endian, order (MSB first)
//increments index i by the number of bytes unpacked
//usage:
//  int i = 0;
//  float x = unpackFloat(&buffer[i], &i);
//  float y = unpackFloat(&buffer[i], &i);
//  float z = unpackFloat(&buffer[i], &i);
float unpackFloat(const void *buf, int *i) {
    const unsigned char *b = (const unsigned char *)buf;
    uint32_t temp = 0;
    *i += 4;
    temp = ((b[0] << 24) |
            (b[1] << 16) |
            (b[2] <<  8) |
             b[3]);
    return *((float *) &temp);
}

//pack method for storing data in network,
//  big endian, byte order (MSB first)
//returns number of bytes packed
//usage:
//  float x, y, z;
//  int i = 0;
//  i += packFloat(&buffer[i], x);
//  i += packFloat(&buffer[i], y);
//  i += packFloat(&buffer[i], z);
int packFloat(void *buf, float x) {
    unsigned char *b = (unsigned char *)buf;
    unsigned char *p = (unsigned char *) &x;
#if defined (_M_IX86) || (defined (CPU_FAMILY) && (CPU_FAMILY == I80X86))
    b[0] = p[3];
    b[1] = p[2];
    b[2] = p[1];
    b[3] = p[0];
#else
    b[0] = p[0];
    b[1] = p[1];
    b[2] = p[2];
    b[3] = p[3];
#endif
    return 4;
}

Ich denke, es ist ein Fehler in der code-Zeile: return *((float *) temp); Es sollte sein: return *((float *) &temp);
Ich bin mir ziemlich sicher, dass dies ein Undefiniertes Verhalten in C++ aufgrund der strengen aliasing-Regeln.

InformationsquelleAutor jholl

14

Können Sie std::copy:
```
float bytesToFloat(uchar b0, uchar b1, uchar b2, uchar b3) 
{ 
    uchar byte_array[] = { b3, b2, b1, b0 };
    float result;
    std::copy(reinterpret_cast<const char*>(&byte_array[0]),
              reinterpret_cast<const char*>(&byte_array[4]),
              reinterpret_cast<char*>(&result));
    return result;
} 
```
Dies vermeidet die union hack, das ist technisch nicht erlaubt, durch die Sprache. Es vermeidet auch die Häufig verwendete reinterpret_cast<float*>(byte_array), die gegen die strict-aliasing-Regeln (es ist erlaubt, neu zu interpretieren jedes Objekt als ein array von char, so die reinterpret_casts in dieser Lösung nicht gegen die strict-aliasing-Regeln).

Es basiert immer noch auf float vier bytes in der Breite und stützt sich auf Ihre vier bytes werden eine gültige floating point Zahl in Ihrer Umsetzung der floating-point-format, aber Sie haben entweder zu machen, diese Annahmen oder schreiben Sie special-handling-code, um die Konvertierung zu tun.
- Dies ist noch nicht tragbar, richtig? Ich bin einfach nur neugierig...
- Nein, es basiert immer noch auf sizeof(float) == 4 und nicht endianness in Betracht. Es verhindert nur, dass reinterpret_cast<float*>(some_uchar_array) und die union hack.
- Ich bin mir ziemlich sicher, dass reinterpret_cast<float*>(byte_array) muss erlaubt sein, wenn die byte_array (1) ordnungsgemäß ausgerichtet ist und (2) enthält tatsächlich ein schweben. Ich denke so, weil es sonst unmöglich wäre, zu memcpy eine float zu einem anderen float (seit memcpy schreibt ein byte-array), und noch ein float ist die archetypische POD-Typ.
- Aber memcpy nicht interpretieren eines byte-array als float; es interpretiert ein schweben als ein byte-array.
- Es ist in der Tat nicht memcpy selbst; offensichtlich funktioniert nur auf byte-arrays. Es ist die Garantie, dass Sie können verwenden Sie die output-byte-array als float.
InformationsquelleAutor James McNellis
4

Gibt es keine Möglichkeit, das zu tun dieses tragbare, da die verschiedenen Plattformen verwenden können:
- unterschiedliche byte-Reihenfolge (big endian vs. little endian)
- unterschiedliche Darstellungen für Gleitkommazahlen (siehe http://en.wikipedia.org/wiki/IEEE_754-1985 für ein Beispiel)
- verschiedenen Größen für floating-point-Werte
Ich Frage mich auch, wo Sie diese 4 bytes aus?

Wenn ich davon ausgehe, dass man Sie aus einem anderen system, und Sie können garantieren, dass beide Systeme verwenden genau die gleiche Methode zum speichern von Gleitkomma-Werten im Speicher, die Verwendung der union-trick. Ansonsten ist dein code ist fast garantiert nicht tragbar.

InformationsquelleAutor Patrick

Wenn Sie möchten, eine portable Möglichkeit, dies zu tun, müssen Sie ein wenig code schreiben zu erkennen, den endian Typ des Systems.

float bytesToFloatA(uchar b0, uchar b1, uchar b2, uchar b3)
{
    float output;

    *((uchar*)(&output) + 3) = b0;
    *((uchar*)(&output) + 2) = b1;
    *((uchar*)(&output) + 1) = b2;
    *((uchar*)(&output) + 0) = b3;

    return output;
}


float bytesToFloatB(uchar b0, uchar b1, uchar b2, uchar b3)
{
    float output;

    *((uchar*)(&output) + 3) = b3;
    *((uchar*)(&output) + 2) = b2;
    *((uchar*)(&output) + 1) = b1;
    *((uchar*)(&output) + 0) = b0;

    return output;
}

float (*correctFunction)(uchar b0, uchar b1, uchar b2, uchar b3) = bytesToFloatA;

if ((*correctFunction)(0x3e, 0xaa, 0xaa, 0xab) != 1.f/3.f) //horrifying, I know
{
  correctFunction = bytesToFloatB;
}

Dass nicht gleich in jedem endian, weil 1./3. ist ein double, nicht ein float. Sollten Sie etwas verwenden wie 1.0f/3.

InformationsquelleAutor JoshD

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.