從其4個複合字節中構建一個32位浮點[C++]

Question

我試圖從其4個複合字節中構建一個32位浮點。有沒有更好的（或更便攜）的方式來做到這一點比用下面的方法？

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

Answer 1

你可以使用一個memcpy（Result）

float f; 
uchar b[] = {b3, b2, b1, b0}; 
memcpy(&f, &b, sizeof(f)); 
return f; 

或工會*（Result）

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; 

但是，這不是比你的代碼的可移植性，因爲沒有保證平臺是小端的，或者使用IEEE binary32甚至sizeof(float) == 4。

（注*：由於@James解釋的那樣，它在技術上不是在標準允許的（C++§[class.union]/1）以訪問聯合成員u.f。）

Answer 2

可以使用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; 
} 

這樣可以避免聯合黑客攻擊，這在技術上不受該語言的限制。它還避免了常用的reinterpret_cast<float*>(byte_array)，它違反了嚴格的別名規則（允許將任何對象重新解釋爲數組char，因此該解決方案中的reinterpret_cast不違反嚴格的別名規則）。

它仍然依賴於float的寬度爲四個字節，並且依賴於您的四個字節是您實現的浮點格式中的有效浮點數，但是您必須做出這些假設或者必須編寫特殊的處理代碼做轉換。

Answer 3

如果你想要一個可移植的方式來做到這一點，你必須編寫一些代碼來檢測系統的永久性。

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

Answer 4

有沒有辦法做到這一點便攜，因爲不同的平臺可以使用：

• 不同的字節順序（大端與小端）
• 不同的浮點值表示（見http://en.wikipedia.org/wiki/IEEE_754-1985舉例）
• 不同大小的浮點數值

我也想知道你從哪裏得到這4個字節？

如果我假設你從另一個系統獲得它們，並且你可以保證這兩個系統使用完全相同的方法在存儲器中存儲浮點值，你可以使用聯合技巧。否則，你的代碼幾乎保證不可移植。

Answer 5

以下函數按網絡字節順序將表示單精度浮點值的字節打包到/從緩衝區中解壓縮字節。只有pack方法需要考慮字節順序，因爲unpack方法通過逐位移位適當的數量，然後將它們OR（或）在一起來顯式地從各個字節構造32位值。這些函數僅適用於存儲32位浮點數的C/C++實現。這對於IEEE 754-1985浮點實現來說是正確的。

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