浮点数转字节组存储，主要用于嵌入式等一些特殊情况，比如串口传数据，其主要思路是将浮点数（通常为4字节），每个字节单独传送，到接收端再将它们组合成一个浮点数即可。在C语言中，我们可以采用union方式实现。
union f_data

{

float fdata;

unsigned char cdata[4];

}data; //单精度的浮点数，便于拆分字节

//如果是双精度的则定义为

//union f_data

//{

//double fdata;

//unsigned char cdata[8];

//}data;
//下面为发送

void send_data(void)

{

data.fdata = 3.14159;

send(data.cdata[0]);

send(data.cdata[1]);

send(data.cdata[2]);

send(data.cdata[3]);

} 


//则接收程序如下

void receive_data(void)

{

data.cdata[0] = receive_byte();

data.cdata[1] = receive_byte();

data.cdata[2] = receive_byte();

data.cdata[3] = receive_byte();

} 

//接收到的数据为data.fdata;
特别注意：
如果发送端和接收端遵循的浮点规则相同，发送和接收的顺序必须一样，顺序、倒序甚至是乱序都无所谓，只要发送和接收两者相同即可
如果两台机器浮点数遵循的标准不一样，则需要调整一些接收字节的顺序



 
 
 

  
本文参考网络上的诸多文章，首先分析了单精度浮点数是如何在机器中存储的，然后将浮点数转换为内存中显示的字节数据，进而又将字节数据转换为单精度浮点数。主要用于对数据存储的分析和字节流转换为有效数据方面。
  
  
这个知识点是自己本科毕业时候遇到的一个难点，今天终于把它搞明白了。念念不忘，必有回响，加油！
  
  
本文主要参考了一下几位博主的文章，非常感谢! 
http://blog.csdn.net/gshgsh1228/article/details/51221354 
http://blog.csdn.net/rayxp/article/details/40855665 
http://www.cnblogs.com/jillzhang/archive/2007/06/24/793901.html 
http://www.cnblogs.com/zhugehq/p/5918599.html


一、浮点数在内存中的表示

对于浮点类型的数据采用单精度类型（float）和双精度类型(double)来存储，float数据占用32bit,double数据占用64bit。不论是float还是double在存储方式上都是遵从IEEE的规范的，float遵从的是IEEE R32.24 ,而double 遵从的是R64.53。 

无论是单精度还是双精度在存储中都分为三个部分： 

    1.  符号位(Sign)             :       0代表正，1代表为负 

    2.  指数位（Exponent）:      用于存储科学计数法中的指数数据，并且采用移位存储 

    3.  尾数部分（Mantissa）：  尾数部分 

 其中float的存储方式如下图所示： 


 而双精度的存储方式为: 


R32.24和R64.53的存储方式都是用科学计数法来存储数据的。因此本文仅仅针对单精度浮点数进行分析，双精度同理可得。



二、单精度浮点数的存储实现



单精度浮点数存储表示

首先来看单精度浮点型float。float占用4字节空间，也就是32位。从左向右数，第1位是符号位（0代表正数，1代表负数），接着是8位指数位，剩下的23位是数据位(实际上有效数字位是24位，因为第一位有效数字总是“1”，不必存储)。如下所示



31 30    23 22                    0
S  EEEEEEEE DDDDDDDDDDDDDDDDDDDDDDD

在这存储实数的四个字节中，将最高地址字节的最高位编号为31，最低地址字节的最低位编号为0，则实数各个部分在这32个二进制位中的分布是这样的：31位是实数符号位，30位是指数符号位，29—23是指数位，22—0位是有效数字位(注意第一位有效数字是不出现在内存中的，它总是“1” )。



单精度浮点数转换步骤

将一个float型转化为内存存储格式的步骤为： 

     （1）先将这个实数的绝对值化为二进制格式。  

     （2）将这个二进制格式实数的小数点左移或右移n位，直到小数点移动到第一个有效数字的右边。  

     （3）从小数点右边第一位开始数出二十三位数字放入第22到第0位。  

     （4）如果实数是正的，则在第31位放入“0”，否则放入“1”。  

     （5）如果n是左移得到的，说明指数是正的，第30位放入“1”。如果n是右移得到的或n=0，则第30位放入“0”。  

     （6）如果n是左移得到的，则将n减去1后化为二进制，并在左边加“0”补足七位，放入第29到第23位。如果n是右移得到的或n=0，则将n化为二进制后在左边加“0”补足七位，再各位求反，再放入第29到第23位。

以12.5为例进行说明： 

（1）12.5实数绝对值二进制形式是 1100.1。 

（2）向左移动3位，转换为科学计数法是1.1001E3，此时n=3。 

（3）将小数点右边第一位开始输出23位放入第22到第0位，即数据位D为：



    DDDDDDDDDDDDDDDDDDDDDDD
    10010000000000000000000

（4）12.5为整数，因此第31位放入“0”，即S=0。 

（5）n是左移得到的，指数为正，则第30位放入“1”。 

（6） n减去1为2，转换为二进制，左边加“0”补足七位，放入第29到第23位。 

此时，由（5）（6）得指数位E为：



    EEEEEEEE
    10000010

综上，得到12.5的二进制存储为：



31 30    23   22                    0
S  EEEEEEEE   DDDDDDDDDDDDDDDDDDDDDDD
0  10000010   10010000000000000000000



验证





补充：

因为浮点数1.0是一个特殊值，这里特地在这里将解析流程从网上摘抄过来分析： 

将实数1.0化为C++的float格式。  

    （1）将1.0化为二进制后是1.00000000000000000000000。  

    （2）这时不用移动小数点了，这就是我们在转化方法里说的n=0的情况。  

    （3）将小数点右边的二十三位有效数字00000000000000000000000放入第22到第0位。  

    （4）因为1.0是正的，所以在第31位里放入“0”。  

    （5）因为n=0，所以在第30位里放入“0”。  

    （6）因为n=0，所以将0补足七位得到0000000，各位求反得到1111111，放入第29到第23位。  

完毕。所以实数1.0用C++的float格式表示是：



31 30    23   22                    0
S  EEEEEEEE   DDDDDDDDDDDDDDDDDDDDDDD
0  01111111   00000000000000000000000

其中最左边一位是第31位，最右边一位是第0位。



三、存储字节数据转换为单精度浮点数



转换为单精度浮点数步骤

将一个内存存储的float二进制格式转化为十进制的步骤：  

  （1）将第22位到第0位的二进制数写出来，在最左边补一位“1”，得到二十四位有效数字。将小数点点在最左边那个“1”的右边。  

  （2）取出第29到第23位所表示的值n。当30位是“0”时将n各位求反。当30位是“1”时将n增1。  

  （3）将小数点左移n位（当30位是“0”时）或右移n位（当30位是“1”时），得到一个二进制表示的实数。  

  （4）将这个二进制实数化为十进制，并根据第31位是“0”还是“1”加上正号或负号即可。

同样以12.5的二进制为例： 

（1） 在最左边补一位“1”，得到二十四位有效数字。将小数点点在最左边那个“1”右边。



    1.10010000000000000000000

（2） 取出第29到第23位所表示的值n。由于30位是“1”，所有将n增1为0000011（即n=3） 

（3） 由于30位是“1”，将小数点右移3位，得到二进制实数为：



    1100. 10000000000000000000

（4） 转换为十进制数，由于31位为“0”，所有结果为12.5



四、代码实现



#include <stdio.h>


/*
*function：ftoc(float fvalue,unsigned char*arr)
*decription:  浮点数转化成四个字节
*input: 浮点数 
*output: 4个字节的字节数组
*/
//例如12.5--0x41 48 00 00;转换完之后，arr[0]-00，arr[1]-00，arr[2]-48，arr[3]-41
void ftoc(float fvalue,unsigned char*arr) 
{
    unsigned char  *pf;
    unsigned char *px;
    unsigned char i;   //计数器 
    pf =(unsigned char *)&fvalue;            /*unsigned char型指针取得浮点数的首地址*/  
    px = arr;                               /*字符数组arr准备存储浮点数的四个字节,px指针指向字节数组arr*/

    for(i=0;i<4;i++)
    {
        *(px+i)=*(pf+i);     /*使用unsigned char型指针从低地址一个字节一个字节取出*/
    }
}

/* 
*function：float ByteToFloat(unsigned char* byteArray) 
*decription:  将字节型转化成32bits浮点型 
*input:       长度为4的字节数组 
*output: 
*/  
float ByteToFloat(unsigned char* byteArray)  
{  
    return *((float*)byteArray);  
}  

int main(int argc, char *argv[])
{

    int i;
    unsigned char byteArray[4];
    ftoc(12.5,byteArray);

    for(i=0;i<4;i++)
        printf("%x  ",byteArray[i]);

    float x=0;
    x = ByteToFloat(byteArray);
    printf("\n%f  ",x);


    return 0;
}

摘自：http://blog.csdn.net/gshgsh1228/article/details/51221354#


  做项目时，碰到一个问题：如何将32位的浮点数转化成4个字节数据进行传送？下面给出算法代码：



（注：该算法来自网上，如侵权，请联系删除。）





/* 

*function：ftoc(float a) 

*decription:  浮点数转化成四个字节 

*input: 

*output: 

*/  

void ftoc(float a)//例如12.5--0x41 48 00 00;转换完之后，e[0]-00，e[1]-00，e[2]-48，e[3]-41  

{  

    unsigned char *px;  

    unsigned char i;  

    unsigned char x[4];                        /*定义字符数组，准备存储浮点数的四个字节*/  

    void          *pf;  

    px=x;                                      /*px指针指向数组x*/  

    pf=&a;                                     /*void 型指针指向浮点数首地址*/  

    for(i=0;i<4;i++)     *(px+i)=*((char *)pf+i); /*强制void 型指针转成char型,因为void型指针不能运算*/  

    for(i=0;i<4;i++)  

        e[i]=x[i];  

}  

下面的代码，是将4个字节转化成32位浮点数




/* 

*function：float ByteToFloat(unsigned char* byteArray) 

*decription:  将字节型转化成32bits浮点型 

*input:长度为4的字节数组 

*output: 

*/  

float ByteToFloat(unsigned char* byteArray)  

{  

    return *((float*)byteArray);  

}  



后面是转化的原理：（整理来自网上）



在C++里，实数（float）是用四个字节即三十二位二进制位来存储的。其中有1位符号位，8位指数位和23位有效数字位。实际上有效数字位是24位，因为第一位有效数字总是“1”，不必存储。  有效数字位是一个二进制纯小数。8位指数位中第一位是符号位，这符号位和一般的符号位不同，它用“1”代表正，用”0“代表负。整个实数的符号位用“1”代表负，“0”代表正。 

    在这存储实数的四个字节中，将最高地址字节的最高位编号为31，最低地址字节的最低位编号为0，则实数各个部分在这32个二进制位中的分布是这样的：31位是实数符号位，30位是指数符号位，29---23是指数位，22---0位是有效数字位。注意第一位有效数字是不出现在内存中的，它总是“1”。      

    将一个实数转化为C++实数存储格式的步骤为： 

    （1）先将这个实数的绝对值化为二进制格式，注意实数的整数部分和小数部

分化为二进制的方法是不同的。 

    （2）将这个二进制格式实数的小数点左移或右移n位，直到小数点移动到第

一个有效数字的右边。 

    （3）从小数点右边第一位开始数出二十三位数字放入第22到第0位。 

    （4）如果实数是正的，则在第31位放入“0”，否则放入“1”。 

    （5）如果n 是左移得到的，说明指数是正的，第30位放入“1”。如果n是右

移得到的或n=0，则第30位放入“0”。 

    （6）如果n是左移得到的，则将n减去一然后化为二进制，并在左边加“0”

补足七位，放入第29到第23位。如果n是右移得到的或n=0，则将n化为二进制后在

左边加“0”补足七位，再各位求反，再放入第29到第23位。 

     

    将一个计算机里存储的实数格式转化为通常的十进制的格式的方法如下： 

    （1）将第22位到第0位的二进制数写出来，在最左边补一位“1”，得到二十

四位有效数字。将小数点点在最左边那个“1”的右边。 

    （2）取出第29到第23位所表示的值n。当30位是“0”时将n各位求反。当30

位是“1”时将n增1。 

    （3）将小数点左移n位（当30位是“0”时）或右移n位（当30位是“1”时）

，得到一个二进制表示的实数。 

    （4）将这个二进制实数化为十进制，并根据第31位是“0”还是“1”加上正

号或负号即可。 



    特别地，实数0用C++的float格式表示是0000000000000000000000000000000

0。 

     

    如果还不太明白，这里举几个例子。 

    一。将23.56化为C++的float格式。 

    （1）将23.56化为二进制后大约是“10111.1000111101011100001”。 

    （2）将小数点左移四位，得到“1.01111000111101011100001”。 

    （3）这已经有了二十四位有效数字，将最左边一位“1”去掉，得到“0111

1000111101011100001”。将它放入第22到第0位。 

    （4）因为23.56是正数，因此在第31位放入“1”。 

    （5）由于我们把小数点左移，因此在第30位放入“1”。 

    （6）因为我们是把小数点左移4位，因此将4减去1得3，化为二进制，并补足

七位得到0000011，放入第29到第23位。 

    完毕。 

    如果把最左边定为第31位，最右边定为第0位，那么在C++里，float格式的2

3.56是这样表示的：01000001101111000111101011100001。相应地-23.56就是这

样表示的：11000001101111000111101011100001。 



    二。将实数0.2356化为C++的float格式。 

    （1）将0.2356化为二进制后大约是0.00111100010100000100100000。 

    （2）将小数点右移三位得到1.11100010100000100100000。 

    （3）从小数点右边数出二十三位有效数字，即11100010100000100100000放

入第22到第0位。 

    （4）由于0.2356是正的，所以在第31位放入“0”。 

    （5）由于我们把小数点右移了，所以在第30位放入“0”。 

    （6）因为小数点被右移了3位，所以将3化为二进制，在左边补“0”补足七

位，得到0000011，各位取反，得到1111100，放入第29到第23位。 

    完毕。因此0.2356用C++的float格式表示是：00111110011100010100000100

100000。其中最左边一位是第31位，最右边一位是第0位。 



    三。将实数1.0化为C++的float格式。 

    （1）将1.0化为二进制后是1.00000000000000000000000。 

    （2）这时不用移动小数点了，这就是我们在转化方法里说的n=0的情况。 

    （3）将小数点右边的二十三位有效数字00000000000000000000000放入第22

到第0位。 

    （4）因为1.0是正的，所以在第31位里放入“0”。 

    （5）因为n=0，所以在第30位里放入“0”。 

    （6）因为n=0，所以将0补足七位得到0000000，各位求反得到1111111，放入

第29到第23位。 

    完毕。所以实数1.0用C++的float格式表示是：0011111110000000000000000

0000000。其中最左边一位是第31位，最右边一位是第0位。

前段时间做的一个小工具，分享一下。
提供浮点数和字节的相互转换。

 
下载
转载于:https://www.cnblogs.com/weipt/p/7771534.html