36

我正在尝试用它的 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;
}
4

6 回答 6

44

你可以使用memcpy（结果）

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

或联合*（结果）

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;

但这并不比您的代码更具可移植性，因为不能保证平台是 little-endian 或float使用 IEEE binary32 甚至sizeof(float) == 4.

（注意*：正如@James所解释的，在标准（C++ §[class.union]/1）中技术上不允许访问联合成员u.f。）

于 2010-10-21T20:19:38.267 回答
19

以下函数按网络字节顺序将表示单精度浮点值的字节打包/解包到/从缓冲区。只有 pack 方法需要考虑字节顺序，因为 unpack 方法通过将各个字节移位适当的数量然后将它们组合在一起来显式地构造 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;
}
于 2010-10-21T20:41:28.777 回答
16

您可以使用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该解决方案中的 s 不违反严格的别名规则）。

它仍然依赖于float四个字节的宽度，并且依赖于您的四个字节是实现的浮点格式中的有效浮点数，但是您要么必须做出这些假设，要么必须编写特殊的处理代码来进行转换。

于 2010-10-21T20:27:40.650 回答
4

没有办法做到这一点，因为不同的平台可以使用：

我也想知道你从哪里得到这 4 个字节？

如果我假设您从另一个系统获取它们，并且您可以保证两个系统使用完全相同的方法将浮点值存储在内存中，那么您可以使用联合技巧。否则，您的代码几乎可以保证是不可移植的。

于 2010-10-21T20:34:43.800 回答
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;
}
于 2010-10-21T20:34:33.383 回答
2

我通常在 C 中使用它——不需要memcpy或union需要。我不知道它可能会破坏 C++ 中的别名规则。

float bytesToFloat(uint8_t *bytes, bool big_endian) {
    float f;
    uint8_t *f_ptr = (uint8_t *) &f;
    if (big_endian) {
        f_ptr[3] = bytes[0];
        f_ptr[2] = bytes[1];
        f_ptr[1] = bytes[2];
        f_ptr[0] = bytes[3];
    } else {
        f_ptr[3] = bytes[3];
        f_ptr[2] = bytes[2];
        f_ptr[1] = bytes[1];
        f_ptr[0] = bytes[0];
    }
    return f;
}

如果您有一整个字节数组需要重新解释为浮点数，您可以在必要时为数组中每个连续的 4 个字节序列调用以下过程，以切换字节顺序（例如，如果您在小端机器，但字节按大端顺序排列）。然后，您可以简单地将uint8_t *数组指针转换为float *，并将内存作为浮点数组访问。

void switchEndianness(uint8_t *bytes) {
    uint8_t b0 = bytes[0];
    uint8_t b1 = bytes[1];
    uint8_t b2 = bytes[2];
    uint8_t b3 = bytes[3];
    bytes[0] = b3;
    bytes[1] = b2;
    bytes[2] = b1;
    bytes[3] = b0;
}
于 2020-07-04T01:42:01.580 回答