IEEE-754标准(32位) 十六进制转换十进制浮点数

因实验需要，读取陀螺仪的数据是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位对应的efloat mantissa = 1 + ((float)(number & 0x7fffff) / 0x7fffff);//将22~0转化为10进制，得到对应的xreturn sign * mantissa * pow(2, exponent);
}
//测试用例
int main()
{unsigned long a = 0x404FC593;//16进制404FC593float 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），

按位与： 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还是1while (!b == 0){if ((1.0 / n) < b){xiaoshu.push_back(1);//若为1则b减去该位所对应的十进制小数大小 ，继续判断低一位，直到b=0b = 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 1ite++;}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;}

IEEE-754标准(32位) 十六进制转换十进制浮点数相关推荐

Java入门之7：Java中的float和double类型的浮点数是怎么按照IEEE 754标准存储的？
前言: 这篇博文,我写了好几天--,里面涉及的基础概念比较多,内容比较多,举例也比较多,想搞清楚明白就难免我自己都会觉得啰嗦,我整理了目录出来,看完需要一点时间,可以自行根据需要.感兴趣的选择阅读 ...
32位十六进制浮点数转换为十进制浮点数的方法
--------------------------------------------- -- 时间:2019-01-11 -- 创建人:Ruo_Xiao -- 邮箱:xclsoftware@163 ...
浮点数的二进制表示(IEEE 754标准)
浮点数是我们在程序里常用的数据类型,它在内存中到底是怎么样的形式存在,是我了解之前是觉得好神奇,以此记录,作为学习笔记.现代计算机中,一般都以IEEE 754标准存储浮点数,这个标准的在内存中存储的形 ...
c语言变凉存储性,C语言数据的表示和存储(IEEE 754标准)
C语言的数据类型大体上分为整数和浮点数两种类型.因为char和指针类型实际上都是整数类型. 移码:给每一个数值加上一个偏置常数即可.通常是加上2^(n-1)或者是2^(n-1)-1这里的n通常取编码的 ...
IEEE 754标准--维基百科
IEEE二进制浮点数算术标准(IEEE 754) 是20世纪80年代以来最广泛使用的浮点数运算标准,为许多CPU与浮点运算器所采用.这个标准定义了表示浮点数的格式(包括负零-0)与反常值(denorm ...
【编程基础】浮点数在计算机中的存储 —— IEEE 754标准
寻求更好的阅读体验,请移步 :浮点数在计算机中的存储 -[Mculover666的个人博客]. 用于存储小数的数据类型是有单精度浮点型(float)和双精度浮点型(double),那么,浮点数在计算机 ...
8位十六进制转换32位十六进制_网络中的数制系统--二进制十六进制与十进制之间的相互转换...
网络中计算机的32位IPv4地址以二进制显示,也会以点分十进制显示.而IPv6的地址是128位,是由数字和A-F组成的十六进制系统.因此,了解并且学会在其三者之间相互转换是非常重要的,让我们能够更好的 ...
2.3.1-4. IEEE 754 标准
棒棒哒加油哦(•̀ω•́)✧ 好的,上个学期说我们学习了,浮点数的基本构成,还有一个原理,浮点数大致上分为接码,还有尾数这样的两个部分组成,那上个小节的末尾我们提到过,如果说我们不能确定一个统一的规则 ...
通过Python实现4字节32位二进制转换为十进制单精度浮点数
与底层设备做通讯,无论是串行通讯还是TCP,经常遇到以字节形式传输的数据格式,得到底层报文后的数据解析就成了重点. 这个百度求解的过程真是一言难尽,大部分都是复制粘贴,不知所云. 这里将最终结果记录一 ...

IEEE-754标准(32位) 十六进制转换十进制浮点数

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

IEEE-754标准(32位) 十六进制转换十进制浮点数相关推荐

最新文章

热门文章