转换类

import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;

/**
 * @ClassName HexConvertToFloatUtil
 * @Author zxq
 * @Date 2020/12/15 0015 13:45
 **/
public class HexConvertUtil {

    public static Float HexConvertToString(String hex) throws IOException {
        byte[] bytes = DataConversion.HexString2Bytes(hex);
        DataInputStream dataInputStream = new DataInputStream(new ByteArrayInputStream(bytes));
        float value = dataInputStream.readFloat();
        System.out.println("转换后数字：" + value);
        System.out.println(value < 0);
        return value;
    }
}


辅助类
 public class DataConversion {
 /**
     * 将指定字符串src，以每两个字符分割转换为16进制形式 如："2B44EFD9" –> byte[]{0x2B, 0×44, 0xEF,
     * 0xD9}
     *
     * @param src
     *            String
     * @return byte[]
     */
    public static byte[] HexString2Bytes(String src) {
        if (null == src || 0 == src.length()) {
            return null;
        }
        byte[] ret = new byte[src.length() / 2];
        byte[] tmp = src.getBytes();
        for (int i = 0; i < (tmp.length / 2); i++) {
            ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);
        }
        return ret;
    }
}

测试网址（百度找的，可用于对比）

http://www.speedfly.cn/tools/hexconvert/
以上

因实验需要，读取陀螺仪的数据是16进制的数据，需要将该数据转化为10进制方便自己查看，理解。记录如下：

1.将（32位）16进制IEEE-754标准浮点数就是用十六进制表示浮点，称为单精度浮点数。

 float类型在内存中占4个字节（32位），最高位用于表示符号;在剩下的31位中，从右向左了8位用于表示指数，其余用于表示尾数。（一个字节是8位）

对应关系如下：

符号位    指数位    尾数位


1位       8位       23位

举例：（1）IEEE-754标准浮点数表示为 404FC593 H（H表示是16进制；）

（2）已知一个数为2.5，IEEE-754标准浮点数表示为 40200000H。

16进制浮点数与十进制的转化步骤：

1、转换为二进制 0 10000000 10011111100010110010011

2、其第0位 为符号位，为0则表示正数，反之1为复数，其读数值用 s 表示；

3、第1～8位为幂数，其读数值用 e 表示；

4、第9～31位共23位作为系数，视为二进制纯小数，假定该小数的十进制值为 x ；

则按照规定，该浮点数的值用十进制表示为：＝ (-1)^s * (1 + x) * 2^(e - 127)

2.幂数的计算

10000000 转换为十进制 128

3.系数的计算

二进制对应的位数的数*2的负位置，再相加

10011111100010110010011

1 1 * 2^(-1)

0 0 * 2^(-2)

0 0 * 2^(-3)

1 1 * 2^(-4)

... ...

1 1 * 2^(-23)

相加可得

0.62321698665618896

4.十进制最后换算

(-1)^0 * (1+ 0.62321698665618896) * 2^(128-127) = 3.246433973312378

举例：

16进制浮点数与十进制的转化步骤：

对于大小为32-bit的浮点数（32-bit为单精度，64-bit浮点数为双精度，80-bit为扩展精度浮点数），

1、其第31 bit为符号位，为0则表示正数，反之为复数，其读数值用s表示；

2、第30～23 bit为幂数，其读数值用e表示；

3、第22～0 bit共23 bit作为系数，视为二进制纯小数，假定该小数的十进制值为x；

则按照规定，该浮点数的值用十进制表示为：＝ (-1)^s * (1 + x) * 2^(e - 127)

例如：对于16进制浮点数49E48E68H来说，如图5：



1、其第31 bit为符号位，为0则表示为正数；（左边是高位，右边是低位）

2、第30～23 bit依次为100 1001 1，读成十进制就是147，即e = 147。

3、第22～0 bit依次为110 0100 1000 1110 0110 1000，也就是二进制的纯小数0.110 0100 1000 1110 0110 1000，其十进制形式为0.78559589385986328125，即x = 0.78559589385986328125。即x = 0.78559589385986328125。

可知：16进制浮点数49E48E68H的10进制表示：

=(-1)^s * (1 + x) * 2^(e - 127)

=(-1)^0 * (1+ 0.78559589385986328125) * 2^(147-127) = 1872333。



下面是实现的代码如下所示：

#include <stdio.h>
#include <math.h>
//十六进制数转浮点数通用方法
float Hex2Float(unsigned long number)
{
	unsigned int sign = (number & 0x80000000) ? -1 : 1;//三目运算符
	unsigned int exponent = ((number >> 23) & 0xff) - 127;//先右移操作，再按位与计算，出来结果是30到23位对应的e
	float mantissa = 1 + ((float)(number & 0x7fffff) / 0x7fffff);//将22~0转化为10进制，得到对应的x
	return sign * mantissa * pow(2, exponent);
}
//测试用例
int main()
{
	
	unsigned long a = 0x404FC593;//16进制404FC593
	float result = Hex2Float(a);

	printf("result = %f \n", result);
	return 0;
}

结果如下：



代码解读：（下边number以49E48E68为例：）

    

（1）首先将number与16进制的8000 0000 做按位与预算，因为16进制8000 0000的二进制除了32位是1之外其他都是0（任何数与0按位与都是0），所以按位与计算是为了得到符号位。

按位与操作规则： 按位与操作 0&0=0; 0&1=0; 1&0=0; 1&1=1



再进行三目运算符操作：括号内表达式非0的话就取-1，是0的话就取1。最终得到符号位。

C语言三目运算符用法：

对于条件表达式b ? x : y，先计算条件b，然后进行判断。如果b的值为true，计算x的值，运算结果为x的值；否则，计算y的值，运算结果为y的值。

（2）右移操作:https://blog.csdn.net/weixin_42216574/article/details/82885102

 左移运算符（<<）


	
将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）。
	
	

	
例：a = a << 2 将a的二进制位左移2位，右补0，
	
	

	
左移1位后a = a * 2;
	
	

	
若左移时舍弃的高位不包含1，则每左移一位，相当于该数乘以2。
	
右移运算符（>>），此处右移23位


	
将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。
	
	

	
操作数每右移一位，相当于该数除以2。

	
例如：a = a >> 2 将a的二进制位右移2位，

		左补0 or 补1 得看被移数是正还是负。
	
	

	
>> 运算符把 expression1 的所有位向右移 expression2 指定的位数。expression1 的符号位被用来填充右移后左边空出来的位。向右移出的位被丢弃。

	
例如，下面的代码被求值后，temp 的值是 -4：

		var temp = -14 >> 2

		-14 （即二进制的 11110010）右移两位等于 -4 （即二进制的 11111100）。
	
	

	
无符号右移运算符（>>>）
	
	

	
>>> 运算符把 expression1 的各个位向右移 expression2 指定的位数。右移后左边空出的位用零来填充。移出右边的位被丢弃。
	
所以上述右移23位之后得到：

0000  0000  0000 0000  0000 0000 1001 0011



右移完成之后再与16进制0xff做按位与运算。ff的二进制是（11111111），

0
			
0
			
0
			
0
			
0
			
0
			
0
			
0
			
0
			
0
			
0
			
0
			
0
			
0
			
0
			
0
			
0
			
0
			
0
			
0
			
0
			
0
			
0
			
0
			
1
			
0
			
0
			
1
			
0
			
0
			
1
			
1
		
按位与：                                                                                                                                                                                         1   1   1    1    1    1    1    1

                                                                                                                        得到：                                                                      1   0   0    1   0   0    1    1     

此步骤得到的就是1到8位，对应第二步。

  （ 3）再与0x7fffff做按位与运算。



 

------------------------------------------上边的代码对应的无符号数据，下边是可以是有符号的：（使用的是unsigned long long 型，因为要考虑数据范围）

char,short ,int ,long,long long,unsigned long long数据范围

速查表：

char -128 ~ +127 (1 Byte)

short -32767 ~ + 32768 (2 Bytes)

unsigned short 0 ~ 65535 (2 Bytes)

int -2147483648 ~ +2147483647 (4 Bytes)

unsigned int 0 ~ 4294967295 (4 Bytes)

long == int

long long -9223372036854775808 ~ +9223372036854775807 (8 Bytes)

double 1.7 * 10^308 (8 Bytes)

unsigned int 0～4294967295

long long的最大值：9223372036854775807

long long的最小值：-9223372036854775808

unsigned long long的最大值：18446744073709551615

__int64的最大值：9223372036854775807

__int64的最小值：-9223372036854775808

unsigned __int64的最大值：18446744073709551615

#include <stdio.h>
#include <math.h>
#include <iostream>

//十六进制数转浮点数通用方法
float Hex2Float(unsigned long long number)
{
	std::cout << "number：" << number << std::endl;
	int sign = (number & 0x80000000) ? -1 : 1;//符号位
	std::cout << "符号位：" << sign << std::endl;
	int exponent = ((number >> 23) & 0xff) - 127;
	std::cout << "e位：" << exponent << std::endl;
	float mantissa = 1 + ((float)(number & 0x7fffff) / 0x7fffff);
	std::cout << "x位：" << mantissa <<std::endl;
	return sign * mantissa * pow(2, exponent);
}
//测试用例
int main()
{

	unsigned long long a = 0xBEAA2737;
	float result = Hex2Float(a);

	printf("result = %f \n", result);
	return 0;
}


结果是：



下面是参考另外一位博主的直接由32位的二进制转化为10进制：

https://blog.csdn.net/qq_35353824/article/details/107773420#comments_14315438

IEEE-754标准（32位）十六进制转十进制浮点数（其实下面第一个程序直接输入的是二进制数）

#include<fstream>
#include <sstream>
#include <iostream>
#include<math.h>
using namespace std;

double BtoD(string x)
{
    double ans;
    int E = 0;
    double D = 0;
    for (int i = 1; i < 32; i++)
    {
        if (i < 9)
        {
            E += (x[i] - '0') << (8 - i);
            //cout << E << endl;
        }
        else
        {
            D += (x[i] - '0') * pow(2 ,(8 - i));
            //cout << D << endl;
        }

    }

    ans = pow(2, E - 127)*(1+D);

    if (x[0] = '1')
        ans = -ans;

    return -ans;
}



int main()
{

    string input;
    ifstream in;
    in.open("D:\\p1.txt");


    if (!in.good())
    {
        cout << "文件打开失败" << endl;
        system("pause");
        return 0;
    }
    while (!in.eof())
    {

        in >> input;
        cout << input << endl;;
        cout << BtoD(input) << endl;

        system("pause");
    }



    in.close();
    cout << "转换完成" << endl;
    system("pause");

    return 0;

}



十进制浮点数 转IEEE-754标准（32位）十六进制：

#include<iostream>
#include<vector>
#include"math.h"
#include<iomanip>
#include <fstream>

using namespace std;

vector<bool> zhengshu;//存整数部分的二进制
vector<bool> xiaoshu;//存小数部分的二进制

vector<bool> get_zhengshu_2b(float a)
{
	vector<bool> x;
	x.clear();
	//八位二进制a xxxx xxxx与1000 0000与，得到每位的二进制数
	for (int i = 0; i < 8; i++)
	{
		if ((((int)a)&(0x80 >> i)))
		{
			x.push_back(1);
		}
		else
		{
			x.push_back(0);
		}
	}
	return x;
}

void get_2b(float a)
{
	//获取整数部分的二进制码
	float fabs_a = fabs(a);//取绝对值
	zhengshu.clear();
	xiaoshu.clear();
	zhengshu = get_zhengshu_2b(fabs_a);

	//获取小数部分的二进制码
	float n = 2;   //小数位的阶数取倒数
	float b = (fabs_a - floor(fabs_a));

	//每次除以2判断该位是0还是1
	while (!b == 0)
	{
		if ((1.0 / n) < b)
		{
			xiaoshu.push_back(1);
			//若为1则b减去该位所对应的十进制小数大小 ，继续判断低一位，直到b=0
			b = b - (1.0 / n);
		}
		else if ((1.0 / n) > b)
		{
			xiaoshu.push_back(0);
		}
		else if ((1.0 / n) == b)
		{
			xiaoshu.push_back(1);
			break;
		}
		n = n * 2;
	}
}
int get_jiema()  //返回阶码
{
	for (int i = 0; i < 8; i++)
	{
		if (zhengshu[i] == 1)//判断从左边起第一个为1的位置
			return 7 - i;		// 返回阶码大小
	}
}
vector<bool> get_yima()//得到移码
{
	int e = get_jiema();
	e = e + 127;  //阶码偏移得到移码
	return get_zhengshu_2b(e);//返回获得的移码的二进制形式
}
vector<bool> get_weima()//获得尾码
{
	vector <bool> m;
	//小数的二进制前插入规格化的码得到尾码
	xiaoshu.insert(xiaoshu.begin(), zhengshu.begin() + (8 - get_jiema()), zhengshu.end());
	m = xiaoshu;
	return m;
}
vector<bool> to_IEEE754(float x)
{
	vector<bool> IEEE;
	IEEE.clear();
	get_2b(x);   //得到x的二进制码
	/*
	//输出原数的二进制形式
	cout << "绝对值的二进制数为：" << endl;
	for (int i = 0; i < zhengshu.size(); i++)
	{
		cout << zhengshu[i];
	}
	cout << ".";
	for (int i = 0; i < xiaoshu.size(); i++)
	{
		cout << xiaoshu[i];
	}
	cout << endl;
	//输出移码
	cout << "移码为：" << endl;


	vector<bool> E = get_yima();
	for (int i = 0; i < 8; i++)
	{
		cout << E[i];
	}
	cout << endl;
	*/
	//组合成短浮点数代码：
	vector<bool> yima;
	yima.clear();
	yima = get_yima();
	vector<bool> weima;
	weima.clear();
	weima = get_weima();

	if (x > 0)//判断并添加符号位
	{
		IEEE.insert(IEEE.end(), 1, 0);
	}
	else
	{
		IEEE.insert(IEEE.end(), 1, 1);
	}
	IEEE.insert(IEEE.end(), yima.begin(), yima.end());//添加移码
	IEEE.insert(IEEE.end(), weima.begin(), weima.end());//添加尾码
	IEEE.insert(IEEE.end(), 32 - 9 - weima.size(), 0);//尾部补零 共32位
	return IEEE;
}
void get_hex(vector<bool> E)//得到十六进制显示
{
	ofstream out;
	out.open("D:\\Desktop\\输出.txt", ios::app);

	vector<bool>::iterator ite = E.begin();//迭代器
	int sum = 0;
	int n = 8;
	while (n--)//八组循环
	{
		for (int i = 0; i < 4; i++)//求每4位的十六进制表示
		{
			sum = sum + (*ite)*pow(2, 3 - i);//8 4 2 1
			ite++;
		}

		cout << setiosflags(ios::uppercase) << hex << sum;//16进制大写字母输出

		out << setiosflags(ios::uppercase) << hex << sum;// 写入文件
		sum = 0;
	}
	out << endl;
	out.close();
	cout << endl;
}



int main()
{

	ifstream in;
	in.open("D:\\P1.txt");
	//求十进制的短浮点数代码//

	if (!in.good())
	{
		cout << "文件打开失败" << endl;
		system("pause");
		return 0;
	}
	while (!in.eof())
	{
		float x;
		vector<bool> IEEE;
		in >> x;
		cout << x <<"转换为：" ;
		IEEE = to_IEEE754(x);
		get_hex(IEEE);
		IEEE.clear();
		cout  << endl;
		//system("pause");
	}
	in.close();
	cout << "转换完成" << endl;
	system("pause");

	return 0;

}

 

	

关注“光谷码农”微信公众号，带你学习最新的Go2新特性！
Go语言有float32和float64两种浮点数类型，对应IEEE754标准的单精度和双精度的浮点数。
我们先看看浮点数的基本用法：
fmt.Println(0.5)
fmt.Println(5E-1) // 5 x 10^-1 = 0.5

fmt.Println(5)
fmt.Println(5E0) // 5 x 10^0 = 5

fmt.Println(50)
fmt.Println(5E1) // 5 x 10^1 = 50
我们可以用普通的格式输入浮点数，也可以通过科学记数法的方式输出浮点数。比如5E-1表示5 x 10^-1也就是0.5。
但是十进制的浮点数面值和计算机可以精确表示的浮点数可能有差异。比如：
fmt.Printf("%.20f", 0.3) // 0.29999999999999998890
这是因为Go语言的浮点数本质上是二进制的规范化的科学记数法(参考：Go之父说：不懂浮点数不配当码农 https://mp.weixin.qq.com/s/rO5EWj5eSkgWu5-0KhshHw)。
为了建设面值浮点数和运行时浮点数转换的误差，Go1.13增加了十六进制进制的浮点数。比如我们可以构造一个1101.001 x 2^1这种浮点数：先将整数和小数部分分开，然后分别以4个二进制bit为一组进行编码，1101.001规范化编码之后对应1101.0010，对应十六进制的0xD.2；然后通过p分隔指数部分0xD.2p1。
fmt.Println(0xD.2p1) // 26.25
那么如何以手工方式将0xD.2p1转为十进制数呢？我们只要反向操作就可以了：首先将0xD.2改写为二进制格式，对应1101.001；然后根据p1得之指数部分是1，因此将1101.001的小数点右移动1位变成11010.01。二进制11010对应是进制的26，而二进制的小数0.01对应1的四分之一，也就是十进制的0.25。因此十六进制的0xD.2p1对应十进制的26.25。
在不超出有效数字个数的前提下，只要一个十进制的浮点数可以通过十六进制进制浮点数表达，那么这个浮点数面值就可以在运行时的浮点数值精度表达。

C# 四个字节十六进制数和单精度浮点数之间的相互转化
即是所谓的IEEE754标准,这也是大多数硬件存储浮点数的标准。单精度浮点数占4个字节，表示范围为：在负数的时候是从 -3.402823E38 到 -1.401298E-45，而在正数的时候是从 1.401298E-45 到 3.402823E38 。

一、在C#中的转换函数为：
1,由四个字节的十六机制数组转浮点数：
    byte[] bytes = new byte[4];
    
    BitConverter.ToSingle(bytes, 0);//从第0个字节开始转换

2,由浮点数转数组：
byte[] bytes = BitConverter.GetBytes(floatValue);

1》这种转换方法经常用于串口通讯中，表示范围足够各种传感器数值传输及工控场合，将要发送的浮点数据转换为4个字节的十六机制数，然后由串口发出，在接收端再将其转换为浮点数。

2》单片机或非.net环境下使用转换程序则不能调用BitConverter类！

二、提供以下代码以供转换：

1》未修改过的如下：可以在C#中直接调用而不用库函数
public static float ToFloat(byte[] data)
{
float a = 0;
byte i;
byte[] x = data;
unsafe
{
void* pf;
fixed (byte* px = x)
{
pf = &a;
for (i = 0; i < data.Length; i++)
{
*((byte*)pf + i) = *(px + i);
}
}
}


return a;
}

public static byte[] ToByte(float data)
{
unsafe
{
byte* pdata = (byte*)&data;
byte[] byteArray = new byte[sizeof(float)];
for (int i = 0; i < sizeof(float); ++i)
byteArray[i] = *pdata++;

return byteArray;
}
}

2》如果对工程进行直接编译会报出一下错误：这是因为C#默认不提供指针支持，只有在不安全代码的形式下才可以用指针。
错误 1 不安全代码只会在使用 /unsafe 编译的情况下出现 E:\Visual Studio 2008\Projects\TEST\testOfFloatConsolt\testOfFloatConsolt\Program.cs 26 13 testOfFloatConsolt
这时选择VS的菜单栏中的项目->"Project"属性->生成->常规->允许不安全代码 勾选即可

三、单片机串口通讯浮点转换函数
我在AVR串口通信协议中用到了这部分，直接将单片机的运算结果（浮点类型）转换为（字节类型）嵌入串口通信协议中，上传至上位机。
下面为符合IEEE754标准将浮点数转换为四个字节的数组的函数源代码：已经用于mega16单片机的串口通信中。
WinAVR-20090313测试通过：
void FloatToByte(float floatNum,unsigned char* byteArry)
{
char* pchar=(char*)&floatNum;
for(int i=0;i<sizeof(float);i++)
{
*byteArry=*pchar;
pchar++;
byteArry++;
}
}

四、下面为符合IEEE754标准的由四个字节型数组转化为相应的浮点数
WinAVR-20090313测试通过：
float ByteToFloat(unsigned char* byteArry)
{
return *((float*)byteArry);
}

调用测试方法：其中USART_Transmit();为向串口发送的函数。
unsigned char floatToByte[4];
FloatToByte(12.15,floatToByte);
float a=ByteToFloat(floatToByte);
FloatToByte(a,floatToByte);
USART_Transmit(floatToByte[0]); 
USART_Transmit(floatToByte[1]); 
USART_Transmit(floatToByte[2]);
USART_Transmit(floatToByte[3]);

//在上位机用串口进行读取时调用

BitConverter.ToSingle(bytes, 0);

//就会转换成12.15，测试方法可以随着需求改变。