c#将字节数组转换为浮点数并将它们除以值[关闭]

Question

我有一个接收字节的休闲代码，可能必须执行转换为浮点数并表示其转换后的值：

 public float DecodeFloat(byte[] data)
    {
        float x = data[3]|data[2]<<8|data[1]<<16|data[0]<<24;
        return x;
    }

     // receive thread 
  private  void ReceiveData() 
    {
        int count=0;

       IPEndPoint remoteIP = new IPEndPoint(IPAddress.Parse("10.0.2.213"), port);
       client = new UdpClient(remoteIP);
        while (true) 
        {
           try 
            {
                IPEndPoint anyIP = new IPEndPoint(IPAddress.Any, 0);
                byte[] data = client.Receive(ref anyIP);

                Vector3 vec,rot;
                float x= DecodeFloat (data);
                float y= DecodeFloat (data + 4);
                float z= DecodeFloat (data + 8);
                float alpha= DecodeFloat (data + 12);
                float theta= DecodeFloat (data +16);
                float phi= DecodeFloat (data+20);

                vec.Set(x,y,z);
                rot.Set (alpha,theta,phi);


                print(">> " + x.ToString() + ", "+ y.ToString() + ", "+ z.ToString() + ", "
                    + alpha.ToString() + ", "+ theta.ToString() + ", "+ phi.ToString());

                // latest UDPpacket
                lastReceivedUDPPacket=x.ToString()+" Packet#: "+count.ToString();
                count = count+1;



            }

请问有没有人给我正确的方法？

Answer 1

给定 4 个字节，如果它是整数数据，您通常只会“移位”(<<)。问题中的代码基本上将数据读取为int（通过“shift”），然后将int 转换为float。几乎可以肯定这不是预期的结果。

由于您想将其解释为float，您可能应该使用：

float val = BitConverter.ToSingle(data, offset);

其中 offset 是 data + 4、data + 8 等中显示的 0、4、8、12 等。这会将 4 个字节（相对于 offset）视为原始 IEEE 754 浮点数据。例如：

float x= BitConverter.ToSingle(data, 0);
float y= BitConverter.ToSingle(data, 4);
float z= BitConverter.ToSingle(data, 8);
float alpha= BitConverter.ToSingle(data, 12);
float theta= BitConverter.ToSingle(data, 16);
float phi= BitConverter.ToSingle(data, 20);

请注意，这是对“字节顺序”的假设 - 请参阅 BitConverter.IsLittleEndian。

---

编辑：来自 cmets，听起来数据是 other-endian；试试：

public static float ReadSingleBigEndian(byte[] data, int offset)
{
    if (BitConverter.IsLittleEndian)
    {
        byte tmp = data[offset];
        data[offset] = data[offset + 3];
        data[offset + 3] = tmp;
        tmp = data[offset + 1];
        data[offset + 1] = data[offset + 2];
        data[offset + 2] = tmp;
    }
    return BitConverter.ToSingle(data, offset);
}
public static float ReadSingleLittleEndian(byte[] data, int offset)
{
    if (!BitConverter.IsLittleEndian)
    {
        byte tmp = data[offset];
        data[offset] = data[offset + 3];
        data[offset + 3] = tmp;
        tmp = data[offset + 1];
        data[offset + 1] = data[offset + 2];
        data[offset + 2] = tmp;
    }
    return BitConverter.ToSingle(data, offset);
}
...
float x= ReadSingleBigEndian(data, 0);
float y= ReadSingleBigEndian(data, 4);
float z= ReadSingleBigEndian(data, 8);
float alpha= ReadSingleBigEndian(data, 12);
float theta= ReadSingleBigEndian(data, 16);
float phi= ReadSingleBigEndian(data, 20);

如果您需要对此进行大规模优化，您还可以使用不安全代码执行一些操作以从移位中构建 int（在移位时选择字节顺序），然​​后执行不安全强制以将 int 作为float;例如（注意我没有在这里检查字节序——它在大字节序的机器上可能会出现异常，但大多数人没有这些）：

public static unsafe float ReadSingleBigEndian(byte[] data, int offset)
{
    int i = (data[offset++] << 24) | (data[offset++] << 16) |
            (data[offset++] << 8) | data[offset];
    return *(float*)&i;
}
public static unsafe float ReadSingleBigEndian(byte[] data, int offset)
{
    int i = (data[offset++]) | (data[offset++] << 8) |
            (data[offset++] << 16) | (data[offset] << 24);
    return *(float*)&i;
}

或者更疯狂，CPU 更安全：

public static float ReadSingleBigEndian(byte[] data, int offset)
{
    return ReadSingle(data, offset, false);
}
public static float ReadSingleLittleEndian(byte[] data, int offset)
{
    return ReadSingle(data, offset, true);
}
private static unsafe float ReadSingle(byte[] data, int offset,
    bool littleEndian)
{
    fixed (byte* ptr = &data[offset])
    {
        if (littleEndian != BitConverter.IsLittleEndian)
        {   // other-endian; swap
            byte b = ptr[0];
            ptr[0] = ptr[3];
            ptr[3] = b;
            b = ptr[1];
            ptr[1] = ptr[2];
            ptr[2] = b;
        }
        return *(float*)ptr;
    }
}