69,373
社区成员
发帖
与我相关
我的任务
分享浮点数的二进制存储？
http://www.matrixq.net/2011/12/10475.html
"IEEE754规定这个偏移量为2^(e-1)-1，e为存储指数的位元的长度,在32位浮点数中存储指数的域有8位因此偏移量位2^(8-1)-1=127。即在上例中E的实际值为-1+127=126=0111 1110。"
------------------------------------------------------------------------------------------------------------------------
浮点数的二进制存储格式：符号位+指数位+尾数位，其中指数位的十进制为正数！
一，为什么说，为了保证指数为正数，实际指数(正数或负数)＋偏移量＝指数(正数)？
说说原因。
"IEEE754规定这个偏移量为2^(e-1)-1，e为存储指数的位元的长度,在32位浮点数中存储指数的域有8位因此偏移量位2^(8-1)-1=127。即在上例中E的实际值为-1+127=126=0111 1110。"
------------------------------------------------------------------------------------------------------------------------
浮点数的二进制存储格式：符号位+指数位+尾数位，其中指数位的十进制为正数！
一，为什么说，为了保证指数为正数，实际指数(正数或负数)＋偏移量＝指数(正数)？
说说原因。
...全文
请发表友善的回复…
发表回复
oanmoa 2012-06-02
- 打赏
- 举报
[Quote=引用 8 楼 的回复:]
在计算机中数据都是按照补码表示的，而且数据类型不同的话就会导致相应的数据表述方式不同。
前C/C++编译器标准都遵照IEEE制定的浮点数表示法来进行float,double运算。这种结构是一种科学计数法，用符号、指数和尾数来表示，底数定为2——即把一个浮点数表示为尾数乘以2的指数次方再添上符号。下面是具体的规格：
符号位 阶码 尾数 长……
[/Quote]
“步骤：按照IEEE浮点数表示法，下面先把38414.4转换为十六进制数。
把整数部和小数部分开处理:整数部直接化十六进制：960E。小数的处理:
0.4=0.5*0+0.25*1+0.125*1+0.0625*0+……”
为什么要把十进制转换为十六进制？
在计算机中数据都是按照补码表示的，而且数据类型不同的话就会导致相应的数据表述方式不同。
前C/C++编译器标准都遵照IEEE制定的浮点数表示法来进行float,double运算。这种结构是一种科学计数法，用符号、指数和尾数来表示，底数定为2——即把一个浮点数表示为尾数乘以2的指数次方再添上符号。下面是具体的规格：
符号位 阶码 尾数 长……
[/Quote]
“步骤：按照IEEE浮点数表示法，下面先把38414.4转换为十六进制数。
把整数部和小数部分开处理:整数部直接化十六进制：960E。小数的处理:
0.4=0.5*0+0.25*1+0.125*1+0.0625*0+……”
为什么要把十进制转换为十六进制？
oanmoa 2012-06-02
- 打赏
- 举报
[Quote=引用 2 楼 的回复:]
我来详述浮点数的存储格式，这里以双精度为例。关于单精度浮点数的格式，请看我在这个帖子中的回复。
http://topic.csdn.net/u/20120516/07/035e7332-d9ef-4a87-8437-7eabcbc8d41d.html
一个double型浮点数存储为64bit,8个字节，分为符号位，阶码，和尾数3部分
1.符号，最高比特，bit63,
2.……
[/Quote]
“3.1415926=1 * 1.5707963 * 2^1”
浮点数存储格式
方法：十进制浮点数－－》转二进制
3.1415926=1 * 1.5707963 * 2^1，是什么意思？
不是应该先把十进制浮点数转二进制么？
我来详述浮点数的存储格式，这里以双精度为例。关于单精度浮点数的格式，请看我在这个帖子中的回复。
http://topic.csdn.net/u/20120516/07/035e7332-d9ef-4a87-8437-7eabcbc8d41d.html
一个double型浮点数存储为64bit,8个字节，分为符号位，阶码，和尾数3部分
1.符号，最高比特，bit63,
2.……
[/Quote]
“3.1415926=1 * 1.5707963 * 2^1”
浮点数存储格式
方法：十进制浮点数－－》转二进制
3.1415926=1 * 1.5707963 * 2^1，是什么意思？
不是应该先把十进制浮点数转二进制么？
赵4老师 2012-06-01
- 打赏
- 举报
C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\float.h
...
#define DBL_DIG 15 /* # of decimal digits of precision */
#define DBL_EPSILON 2.2204460492503131e-016 /* smallest such that 1.0+DBL_EPSILON != 1.0 */
#define DBL_MANT_DIG 53 /* # of bits in mantissa */
#define DBL_MAX 1.7976931348623158e+308 /* max value */
#define DBL_MAX_10_EXP 308 /* max decimal exponent */
#define DBL_MAX_EXP 1024 /* max binary exponent */
#define DBL_MIN 2.2250738585072014e-308 /* min positive value */
#define DBL_MIN_10_EXP (-307) /* min decimal exponent */
#define DBL_MIN_EXP (-1021) /* min binary exponent */
#define _DBL_RADIX 2 /* exponent radix */
#define _DBL_ROUNDS 1 /* addition rounding: near */
#define FLT_DIG 6 /* # of decimal digits of precision */
#define FLT_EPSILON 1.192092896e-07F /* smallest such that 1.0+FLT_EPSILON != 1.0 */
#define FLT_GUARD 0
#define FLT_MANT_DIG 24 /* # of bits in mantissa */
#define FLT_MAX 3.402823466e+38F /* max value */
#define FLT_MAX_10_EXP 38 /* max decimal exponent */
#define FLT_MAX_EXP 128 /* max binary exponent */
#define FLT_MIN 1.175494351e-38F /* min positive value */
#define FLT_MIN_10_EXP (-37) /* min decimal exponent */
#define FLT_MIN_EXP (-125) /* min binary exponent */
#define FLT_NORMALIZE 0
#define FLT_RADIX 2 /* exponent radix */
#define FLT_ROUNDS 1 /* addition rounding: near */
...
liangbch 2012-06-01
- 打赏
- 举报
先重复一下维基百科关于浮点数指数部分不是的解释。
[Quote]
指数偏移值指数偏移值(exponent bias)，是指浮点数表示法中的指数域的编码值为指数的实际值加上某个固定的值，IEEE 754标准规定该固定值为 2^(e-1) - 1，其中的e为存储指数的位元的长度。
以单精度浮点数为例，它的指数域是8个位元，固定偏移值是2^(8-1) - 1 = 128-1 = 127. 单精度浮点数的指数部分实际取值是从128到-127。例如指数实际值为17(10)，在单精度浮点数中的指数域编码值为144(10)， 即144(10) = 17(10) + 127(10).
这里(10)表示10进制数的意思。
采用指数的实际值加上固定的偏移值的办法表示浮点数的指数，好处是可以用长度为e个位元的无符号整数来表示所有的指数取值，这使得两个浮点数的指数大小的比较更为容易。
[/Quote]
我在6楼提到
[Quote=引用 6 楼 的回复:]
单精度浮点数的绝对值的范围为1 *2^-127 to 1×2^128( 实际上由于尾数部分可小于1，实际表示的最小的数是2^-149.)，其阶码是-127 to 128[/Quote]
我在3楼提到，提到
[Quote=引用 3 楼 的回复:]
首先将浮点是f表示为 s * a * 2^k 的形式，s=1 或者 -1. a>=1.0 而小于 2.0
[/Quote]
我在3楼也提到
[Quote=引用 3 楼 的回复:]
因为尾数a,最高bit总是1(大于1.0)，故存储时略去最高bit,而存储其余的23bit
[/Quote]
这里澄清一下，当浮点数f小于2^-127时,如果f表示为 s * a * 2^k 的形式，而且要求
a>=1.0 而小于 2.0，这时k的值会小于-127. 而阶码部分的最小值是-127,所以，这样
数就无法用单精度浮点格式来表示了。为了表示比2^-127更小的数，IEEE754标准规定，
当浮点数f小于2^-127时，阶码固定为-127，而浮点数的尾数部分可小于1.这就是我在6楼
提到的 ( 实际上由于尾数部分可小于1，实际表示的最小的数是2^-149.)
[Quote]
指数偏移值指数偏移值(exponent bias)，是指浮点数表示法中的指数域的编码值为指数的实际值加上某个固定的值，IEEE 754标准规定该固定值为 2^(e-1) - 1，其中的e为存储指数的位元的长度。
以单精度浮点数为例，它的指数域是8个位元，固定偏移值是2^(8-1) - 1 = 128-1 = 127. 单精度浮点数的指数部分实际取值是从128到-127。例如指数实际值为17(10)，在单精度浮点数中的指数域编码值为144(10)， 即144(10) = 17(10) + 127(10).
这里(10)表示10进制数的意思。
采用指数的实际值加上固定的偏移值的办法表示浮点数的指数，好处是可以用长度为e个位元的无符号整数来表示所有的指数取值，这使得两个浮点数的指数大小的比较更为容易。
[/Quote]
我在6楼提到
[Quote=引用 6 楼 的回复:]
单精度浮点数的绝对值的范围为1 *2^-127 to 1×2^128( 实际上由于尾数部分可小于1，实际表示的最小的数是2^-149.)，其阶码是-127 to 128[/Quote]
我在3楼提到，提到
[Quote=引用 3 楼 的回复:]
首先将浮点是f表示为 s * a * 2^k 的形式，s=1 或者 -1. a>=1.0 而小于 2.0
[/Quote]
我在3楼也提到
[Quote=引用 3 楼 的回复:]
因为尾数a,最高bit总是1(大于1.0)，故存储时略去最高bit,而存储其余的23bit
[/Quote]
这里澄清一下，当浮点数f小于2^-127时,如果f表示为 s * a * 2^k 的形式，而且要求
a>=1.0 而小于 2.0，这时k的值会小于-127. 而阶码部分的最小值是-127,所以，这样
数就无法用单精度浮点格式来表示了。为了表示比2^-127更小的数，IEEE754标准规定，
当浮点数f小于2^-127时，阶码固定为-127，而浮点数的尾数部分可小于1.这就是我在6楼
提到的 ( 实际上由于尾数部分可小于1，实际表示的最小的数是2^-149.)
oanmoa 2012-06-01
- 打赏
- 举报
[Quote=引用 5 楼 的回复:]
移码
[/Quote]
"单精度浮点数的绝对值的范围为1 *2^-127 to 1×2^128"
float单精度浮点数32位。为什么说其取值范围是：1 *2^-127 to 1×2^128？
移码
[/Quote]
"单精度浮点数的绝对值的范围为1 *2^-127 to 1×2^128"
float单精度浮点数32位。为什么说其取值范围是：1 *2^-127 to 1×2^128？
oanmoa 2012-06-01
- 打赏
- 举报
各位：
说说18位！
说说18位！
liangbch 2012-06-01
- 打赏
- 举报
其最小的规约数 与 C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\float.h 中的
FLT_MIN 定义相符。其 最小的非规约数 与我的测试结果和百度百科相符。
规约数 意味着 尾数的最高位为1
非规约数 则没有这样的要求。
FLT_MIN 定义相符。其 最小的非规约数 与我的测试结果和百度百科相符。
规约数 意味着 尾数的最高位为1
非规约数 则没有这样的要求。
liangbch 2012-06-01
- 打赏
- 举报
17楼也不用说风凉话。
百度百科不权威，我也承认，但也不是能自己吃不准的东西来压人。
维基百科的中文网页（http://zh.wikipedia.org/wiki/IEEE_754）提到：
最小的非规约数 ±2^-23 × 2^-126 = ±2^-149 ≈ ±1.4×10-45
最小的规约数 ±2^-126 ≈ ±1.18×10-38
其最小的规约数 C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\float.h 中的
FLT_MIN 定义相符。其 最小的非规约数 与我的测试结果和百度百科相符。
百度百科不权威，我也承认，但也不是能自己吃不准的东西来压人。
维基百科的中文网页（http://zh.wikipedia.org/wiki/IEEE_754）提到：
最小的非规约数 ±2^-23 × 2^-126 = ±2^-149 ≈ ±1.4×10-45
最小的规约数 ±2^-126 ≈ ±1.18×10-38
其最小的规约数 C:\Program Files\Microsoft Visual Studio 10.0\VC\crt\src\float.h 中的
FLT_MIN 定义相符。其 最小的非规约数 与我的测试结果和百度百科相符。
oanmoa 2012-06-01
- 打赏
- 举报
符号位用移码的方法使其值变正数。
尾数部分，是保存小数点之后的值。
怎样解码？
尾数部分，是保存小数点之后的值。
怎样解码？
赵4老师 2012-06-01
- 打赏
- 举报
百度百科能比float.h更权威？有人本末倒置了吧。
liangbch 2012-06-01
- 打赏
- 举报
哪有你这么判断的？“1.0f+f != 1.0f”。
浮点数的精度有限，当一个很小的数 和 1(这里是一个很大的数）相加，由于误差的原因，这个很小数的就不起作用了。
另外，按照你的逻辑，假定这个数是double型，那么你能说double能够表示的最小数是2.22045e-016吗？事实上，double型数能够表示的1.7E-308～1.7E+308，能够表示最小的数是1.7E-308，远比2.22e-16小的多。见百度百科《双精度浮点数》http://baike.baidu.com/view/2393520.htm
12楼的运行结果是：
这和百度百科单精度中给出的范围是完全一样的。
[Quote=]
单精度数，是指计算机表达实数近似值的一种方式。VB中，Single（单精度浮点型）变量存储为 IEEE 32 位（4 个字节）浮点数值的形式，它的范围在负数的时候是从 -3.402823E38 到 -1.401298E-45，而在正数的时候是从 1.401298E-45 到 3.402823E38 。
[/Quote] 见百度百科 ：http://baike.baidu.com/view/1007029.htm
浮点数的精度有限，当一个很小的数 和 1(这里是一个很大的数）相加，由于误差的原因，这个很小数的就不起作用了。
另外，按照你的逻辑，假定这个数是double型，那么你能说double能够表示的最小数是2.22045e-016吗？事实上，double型数能够表示的1.7E-308～1.7E+308，能够表示最小的数是1.7E-308，远比2.22e-16小的多。见百度百科《双精度浮点数》http://baike.baidu.com/view/2393520.htm
12楼的运行结果是：
f= 2
f= 1
f= 0.5
f= 0.25
f= 0.125
f= 0.0625
f= 0.03125
f= 0.015625
f= 0.0078125
f= 0.00390625
f= 0.00195313
f= 0.000976563
f= 0.000488281
f= 0.000244141
f= 0.00012207
f= 6.10352e-005
f= 3.05176e-005
f= 1.52588e-005
f= 7.62939e-006
f= 3.8147e-006
f= 1.90735e-006
f= 9.53674e-007
f= 4.76837e-007
f= 2.38419e-007
f= 1.19209e-007
f= 5.96046e-008
f= 2.98023e-008
f= 1.49012e-008
f= 7.45058e-009
f= 3.72529e-009
f= 1.86265e-009
f= 9.31323e-010
f= 4.65661e-010
f= 2.32831e-010
f= 1.16415e-010
f= 5.82077e-011
f= 2.91038e-011
f= 1.45519e-011
f= 7.27596e-012
f= 3.63798e-012
f= 1.81899e-012
f= 9.09495e-013
f= 4.54747e-013
f= 2.27374e-013
f= 1.13687e-013
f= 5.68434e-014
f= 2.84217e-014
f= 1.42109e-014
f= 7.10543e-015
f= 3.55271e-015
f= 1.77636e-015
f= 8.88178e-016
f= 4.44089e-016
f= 2.22045e-016
f= 1.11022e-016
f= 5.55112e-017
f= 2.77556e-017
f= 1.38778e-017
f= 6.93889e-018
f= 3.46945e-018
f= 1.73472e-018
f= 8.67362e-019
f= 4.33681e-019
f= 2.1684e-019
f= 1.0842e-019
f= 5.42101e-020
f= 2.71051e-020
f= 1.35525e-020
f= 6.77626e-021
f= 3.38813e-021
f= 1.69407e-021
f= 8.47033e-022
f= 4.23516e-022
f= 2.11758e-022
f= 1.05879e-022
f= 5.29396e-023
f= 2.64698e-023
f= 1.32349e-023
f= 6.61744e-024
f= 3.30872e-024
f= 1.65436e-024
f= 8.27181e-025
f= 4.1359e-025
f= 2.06795e-025
f= 1.03398e-025
f= 5.16988e-026
f= 2.58494e-026
f= 1.29247e-026
f= 6.46235e-027
f= 3.23117e-027
f= 1.61559e-027
f= 8.07794e-028
f= 4.03897e-028
f= 2.01948e-028
f= 1.00974e-028
f= 5.04871e-029
f= 2.52435e-029
f= 1.26218e-029
f= 6.31089e-030
f= 3.15544e-030
f= 1.57772e-030
f= 7.88861e-031
f= 3.9443e-031
f= 1.97215e-031
f= 9.86076e-032
f= 4.93038e-032
f= 2.46519e-032
f= 1.2326e-032
f= 6.16298e-033
f= 3.08149e-033
f= 1.54074e-033
f= 7.70372e-034
f= 3.85186e-034
f= 1.92593e-034
f= 9.62965e-035
f= 4.81482e-035
f= 2.40741e-035
f= 1.20371e-035
f= 6.01853e-036
f= 3.00927e-036
f= 1.50463e-036
f= 7.52316e-037
f= 3.76158e-037
f= 1.88079e-037
f= 9.40395e-038
f= 4.70198e-038
f= 2.35099e-038
f= 1.17549e-038
f= 5.87747e-039
f= 2.93874e-039
f= 1.46937e-039
f= 7.34684e-040
f= 3.67342e-040
f= 1.83671e-040
f= 9.18355e-041
f= 4.59177e-041
f= 2.29589e-041
f= 1.14794e-041
f= 5.73972e-042
f= 2.86986e-042
f= 1.43493e-042
f= 7.17465e-043
f= 3.58732e-043
f= 1.79366e-043
f= 8.96831e-044
f= 4.48416e-044
f= 2.24208e-044
f= 1.12104e-044
f= 5.60519e-045
f= 2.8026e-045
f= 1.4013e-045
这和百度百科单精度中给出的范围是完全一样的。
[Quote=]
单精度数，是指计算机表达实数近似值的一种方式。VB中，Single（单精度浮点型）变量存储为 IEEE 32 位（4 个字节）浮点数值的形式，它的范围在负数的时候是从 -3.402823E38 到 -1.401298E-45，而在正数的时候是从 1.401298E-45 到 3.402823E38 。
[/Quote] 见百度百科 ：http://baike.baidu.com/view/1007029.htm
赵4老师 2012-06-01
- 打赏
- 举报
#include <stdio.h>
void main() {
float f=2.0f;
while ( 1.0f+f != 1.0f) {
printf("f=%.6g\n",f);
f=f/2.0f;
}
}
f=2
f=1
f=0.5
f=0.25
f=0.125
f=0.0625
f=0.03125
f=0.015625
f=0.0078125
f=0.00390625
f=0.00195313
f=0.000976563
f=0.000488281
f=0.000244141
f=0.00012207
f=6.10352e-005
f=3.05176e-005
f=1.52588e-005
f=7.62939e-006
f=3.8147e-006
f=1.90735e-006
f=9.53674e-007
f=4.76837e-007
f=2.38419e-007
f=1.19209e-007
f=5.96046e-008
f=2.98023e-008
f=1.49012e-008
f=7.45058e-009
f=3.72529e-009
f=1.86265e-009
f=9.31323e-010
f=4.65661e-010
f=2.32831e-010
f=1.16415e-010
f=5.82077e-011
f=2.91038e-011
f=1.45519e-011
f=7.27596e-012
f=3.63798e-012
f=1.81899e-012
f=9.09495e-013
f=4.54747e-013
f=2.27374e-013
f=1.13687e-013
f=5.68434e-014
f=2.84217e-014
f=1.42109e-014
f=7.10543e-015
f=3.55271e-015
f=1.77636e-015
f=8.88178e-016
f=4.44089e-016
f=2.22045e-016
可见float在VC下实际是用double实现和计算的。
liangbch 2012-06-01
- 打赏
- 举报
有什么问题？
赵4老师 2012-06-01
- 打赏
- 举报
楼上的测试方法有问题。
liangbch 2012-06-01
- 打赏
- 举报
[Quote=引用 11 楼 的回复:]
#define FLT_MIN 1.175494351e-38F /* min positive value */
[/Quote]
2^-149 = 1.401298e-45,我试验的测试结果也正是这一点，下面是我的测试代码。
#define FLT_MIN 1.175494351e-38F /* min positive value */
[/Quote]
2^-149 = 1.401298e-45,我试验的测试结果也正是这一点，下面是我的测试代码。
void test()
{
float f=2.0;
while ( f>0.0)
{
printf("f=%20g\n",f);
f=f/2.0;
}
}liangbch 2012-05-31
- 打赏
- 举报
单精度浮点数存储格式是这样的
1. 存储为32bit,4个字节，分为符号位，阶码，和尾数3部分
1.符号，最高位，bit31,
2.阶码，8bit, bit23 到 bit30
3.尾数：23bit, bit0 到 bit22
2. 表示方式：
首先将浮点是f表示为 s * a * 2^k 的形式，s=1 或者 -1. a>=1.0 而小于 2.0
s=1，则浮点数是整数，则bit31=0, 否则浮点数是负数，bit31=1
阶码实际存储为 k+127.
因为尾数a,最高bit总是1(大于1.0)，故存储时略去最高bit,而存储其余的23bit
以你提供的0.5为例，在内存中的连续4个字节为
00 00 00 3f
改为从高到低存储:
0x3f,0x00,0x00,0x00,
转化为2进制：
0011 1111 0000 0000 0000 0000 0000 0000
分成符号，阶码，尾数3部分：
0 01111110 00000000000000000000000
阶码为 01111110=127+(-1)， 尾数00000000000000000000000，由于省略最高位，实为
100000000000000000000000，也就是1.0000。 这和其存储格式完全吻合。
liangbch 2012-05-31
- 打赏
- 举报
我来详述浮点数的存储格式，这里以双精度为例。关于单精度浮点数的格式，请看我在这个帖子中的回复。
http://topic.csdn.net/u/20120516/07/035e7332-d9ef-4a87-8437-7eabcbc8d41d.html
一个double型浮点数存储为64bit,8个字节，分为符号位，阶码，和尾数3部分
1.符号，最高比特，bit63,
2.阶码，11比特, bit52 到 bit62
3.尾数：52比特, bit0 到 bit51
2. 表示方式：
首先将浮点是f表示为 s * a * 2^k 的形式，s是符号，s=1或者-1.
a是尾数，相当于科学计数法的小数部分，a>=1.0 而小于 2.0。
k是解码，相当于科学计数法的指数部分。s=1，则浮点数是正数，
bit63=0, 否则浮点数是负数，bit63=1。 阶码实际存储为 k+1023.
因为尾数a,最高bit总是1(大于1.0)，故存储时略去最高bit,而存储其余的52bit。
例如：
3.1415926=1 * 1.5707963 * 2^1, 则
符号为是0
11bit阶码存储为1+1023=1024，2进制形式为10000000000
尾数是 1.5707963=1.1001001000011111101101001101000100101101100001001001b,
略去最高为1,小数部分的52bit是"1001001000011111101101001101000100101101100001001001"
上面是理论分析，下面我们来看看这是数在内存中表示，是否和我们的分析一致.
从浮点数的地址取8个字节，我的程序显示，这8个字节是(代码见楼下)：
4a d8 12 4d fb 21 09 40
Intel的格式是小尾(Little Endian)方式，低位字节排放在内存的低端，高位字节排放在内存的高端。
将高低位字节交换后的:
40 09 21 fb 4d 12 d8 4a
将16进制变化为2进制：结果为：
01000000 00001001 00100001 11111011 01001101 00010010 11011000 01001010
将这64bit按照1,11,52分为3部分，他们是
{0},{10000000000},{1001001000011111101101001101000100101101100001001010},和上面的理论值
相比，只有最低为2个比特不同，在误差范围内，他们是完全相同的。其误差可能是编译器转化的误差，
对于1.5707963的2进制表示，我是用Windows计算的，输入1.5707963，然后乘以2^52将其转化为整数，
再切换到2进制，就得到这53比特2进制数了。
http://topic.csdn.net/u/20120516/07/035e7332-d9ef-4a87-8437-7eabcbc8d41d.html
一个double型浮点数存储为64bit,8个字节，分为符号位，阶码，和尾数3部分
1.符号，最高比特，bit63,
2.阶码，11比特, bit52 到 bit62
3.尾数：52比特, bit0 到 bit51
2. 表示方式：
首先将浮点是f表示为 s * a * 2^k 的形式，s是符号，s=1或者-1.
a是尾数，相当于科学计数法的小数部分，a>=1.0 而小于 2.0。
k是解码，相当于科学计数法的指数部分。s=1，则浮点数是正数，
bit63=0, 否则浮点数是负数，bit63=1。 阶码实际存储为 k+1023.
因为尾数a,最高bit总是1(大于1.0)，故存储时略去最高bit,而存储其余的52bit。
例如：
3.1415926=1 * 1.5707963 * 2^1, 则
符号为是0
11bit阶码存储为1+1023=1024，2进制形式为10000000000
尾数是 1.5707963=1.1001001000011111101101001101000100101101100001001001b,
略去最高为1,小数部分的52bit是"1001001000011111101101001101000100101101100001001001"
上面是理论分析，下面我们来看看这是数在内存中表示，是否和我们的分析一致.
从浮点数的地址取8个字节，我的程序显示，这8个字节是(代码见楼下)：
4a d8 12 4d fb 21 09 40
Intel的格式是小尾(Little Endian)方式，低位字节排放在内存的低端，高位字节排放在内存的高端。
将高低位字节交换后的:
40 09 21 fb 4d 12 d8 4a
将16进制变化为2进制：结果为：
01000000 00001001 00100001 11111011 01001101 00010010 11011000 01001010
将这64bit按照1,11,52分为3部分，他们是
{0},{10000000000},{1001001000011111101101001101000100101101100001001010},和上面的理论值
相比，只有最低为2个比特不同，在误差范围内，他们是完全相同的。其误差可能是编译器转化的误差，
对于1.5707963的2进制表示，我是用Windows计算的，输入1.5707963，然后乘以2^52将其转化为整数，
再切换到2进制，就得到这53比特2进制数了。
W170532934 2012-05-31
- 打赏
- 举报
推荐楼主看《深入理解计算机系统》
giant7 2012-05-31
- 打赏
- 举报
在计算机中数据都是按照补码表示的，而且数据类型不同的话就会导致相应的数据表述方式不同。
前C/C++编译器标准都遵照IEEE制定的浮点数表示法来进行float,double运算。这种结构是一种科学计数法，用符号、指数和尾数来表示，底数定为2——即把一个浮点数表示为尾数乘以2的指数次方再添上符号。下面是具体的规格：
符号位 阶码 尾数 长度
float 1 8 23 32
double 1 11 52 64
以下通过几个例子讲解浮点数如何转换为二进制数
例一：
已知：double类型38414.4。
求：其对应的二进制表示。
分析：double类型共计64位，折合8字节。由最高到最低位分别是第63、62、61、……、0位：
最高位63位是符号位，1表示该数为负，0表示该数为正；
62-52位，一共11位是指数位；
51-0位，一共52位是尾数位。
步骤：按照IEEE浮点数表示法，下面先把38414.4转换为十六进制数。
把整数部和小数部分开处理:整数部直接化十六进制：960E。小数的处理:
0.4=0.5*0+0.25*1+0.125*1+0.0625*0+……
实际上这永远算不完！这就是著名的浮点数精度问题。所以直到加上前面的整数部分算够53位就行了。隐藏位技术：最高位的1不写入内存（最终保留下来的还是52位）。
如果你够耐心，手工算到53位那么因该是：38414.4(10)=1001011000001110.0110011001100110011001100110011001100(2)
科学记数法为：1.001011000001110 0110011001100110011001100110011001100，右移了15位，所以指数为15。或者可以如下理解：
1.001011000001110 0110011001100110011001100110011001100×2^15
于是来看阶码，按IEEE标准一共11位，可以表示范围是-1024 ~ 1023。因为指数可以为负，为了便于计算，规定都先加上1023(2^10-1)，在这里，阶码：15+1023=1038。二进制表示为：100 00001110；
符号位：因为38414.4为正对应 为0；
合在一起（注：尾数二进制最高位的1不要）：
01000000 11100010 11000001 110 01100 11001100 11001100 11001100 11001100
例二：
已知：整数3490593(16进制表示为0x354321)。
求：其对应的浮点数3490593.0的二进制表示。
解法如下：
先求出整数3490593的二进制表示：
H: 3 5 4 3 2 1 （十六进制表示）
B: 0011 0101 0100 0011 0010 0001 （二进制表示）
│←───── 21────→│
即：
1.1010101000011001000012×221
可见，从左算起第一个1后有21位，我们将这21为作为浮点数的小数表示，单精度浮点数float由符号位1位，指数域位k=8位，小数域位(尾数)n=23位构成，因此对上面得到的21位小数位我们还需要补上2个0，得到浮点数的小数域表示为：
1 0101 0100 0011 0010 0001 00
float类型的偏置量Bias=2k-1-1=28-1-1=127，但还要补上刚才因为右移作为小数部分的21位，因此偏置量为127+21=148，就是IEEE浮点数表示标准：
V = (-1)s×M×2E
E = e-Bias
中的e，此前计算Bias=127，刚好验证了E=148-127=21。
将148转为二进制表示为10010100，加上符号位0，最后得到二进制浮点数表示1001010010101010000110010000100，其16进制表示为：
H: 4 A 5 5 0 C 8 4
B: 0100 1010 0101 0101 0000 1100 1000 0100
|←──── 21 ─────→ |
1|←─8 ─→||←───── 23 ─────→ |
这就是浮点数3490593.0(0x4A550C84)的二进制表示。
例三：
0.5的二进制形式是0.1
它用浮点数的形式写出来是如下格式
0 01111110 00000000000000000000000
符号位 阶码 小数位
正数符号位为0，负数符号位为1
阶码是以2为底的指数
小数位表示小数点后面的数字
下面我们来分析一下0.5是如何写成0 01111110 00000000000000000000000
首先0.5是正数所以符号位为0
再来看阶码部分,0.5的二进制数是0.1,而0.1是1.0*2^(-1),所以我们总结出来:
要把二进制数变成(1.f)*2^(exponent)的形式,其中exponent是指数
而由于阶码有正负之分所以阶码=127+exponent;
即阶码=127+(-1)=126 即 01111110
余下的小数位为二进制小数点后面的数字,即00000000000000000000000
由以上分析得0.5的浮点数存储形式为0 01111110 00000000000000000000000
注：如果只有小数部分,那么需要右移小数点. 比如右移3位才能放到第一个1的后面, 阶码就是127-3=124.
例四 （20.59375）10 =（10100.10011 ）2
首先分别将整数和分数部分转换成二进制数：
20.59375＝10100.10011
然后移动小数点，使其在第1，2位之间
10100.10011＝1.010010011×2^4 即e＝4
于是得到：
S＝0， E＝4＋127＝131， M＝010010011
最后得到32位浮点数的二进制存储格式为：
0100 1001 1010 0100 1100 0000 0000 0000＝(41A4C000)16
例五：
-12.5转为单精度二进制表示
12.5:
1. 整数部分12，二进制为1100; 小数部分0.5, 二进制是.1，先把他们连起来，从第一个1数起取24位（后面补0）：
1100.10000000000000000000
这部分是有效数字。（把小数点前后两部分连起来再取掉头前的1，就是尾数）
2. 把小数点移到第一个1的后面，需要左移3位（1.10010000000000000000000*2^3）, 加上偏移量127：127+3=130，二进制是10000010，这是阶码。
3. -12.5是负数，所以符号位是1。把符号位，阶码和尾数连起来。注意，尾数的第一位总是1，所以规定不存这一位的1，只取后23位：
1 10000010 10010000000000000000000
把这32位按8位一节整理一下，得：
11000001 01001000 00000000 00000000
就是十六进制的 C1480000.
例六：
2.025675
1. 整数部分2，二进制为10; 小数部分0.025675, 二进制是.0000011010010010101001，先把他们连起来，从第一个1数起取24位（后面补0）：
10.0000011010010010101001
这部分是有效数字。把小数点前后两部分连起来再取掉头前的1，就是尾数: 00000011010010010101001
2. 把小数点移到第一个1的后面，左移了1位, 加上偏移量127：127+1=128，二进制是10000000，这是阶码。
3. 2.025675是正数，所以符号位是0。把符号位，阶码和尾数连起来：
0 10000000 00000011010010010101001
把这32位按8位一节整理一下，得：
01000000 00000001 10100100 10101001
就是十六进制的 4001A4A9.
例七：
(逆向求十进制整数)一个浮点二进制数手工转换成十进制数的例子：
假设浮点二进制数是 1011 1101 0100 0000 0000 0000 0000 0000
按1，8，23位分成三段：
1 01111010 10000000000000000000000
最后一段是尾数。前面加上"1.", 就是 1.10000000000000000000000
下面确定小数点位置。由E = e-Bias，阶码E是01111010，加上00000101才是01111111（127），
所以他减去127的偏移量得e=-5。（或者化成十进制得122，122-127=-5）。
因此尾数1.10（后面的0不写了）是小数点右移5位的结果。要复原它就要左移5位小数点，得0.0000110, 即十进制的0.046875 。
最后是符号：1代表负数，所以最后的结果是 -0.046875 。
注意：其他机器的浮点数表示方法可能与此不同. 不能任意移植。
再看一例(类似例七)：
比如：53004d3e
二进制表示为：
01010011000000000100110100111110
按照1个符号 8个指数 23个小数位划分
0 10100110 00000000100110100111110
正确的结果转出来应该是551051722752.0
该怎么算？
好，我们根据IEEE的浮点数表示规则划分，得到这个浮点数的小数位是：
00000000100110100111110
那么它的二进制表示就应该是：
1.000000001001101001111102 × 239
这是怎么来的呢？ 别急，听我慢慢道来。
标准化公式中的M要求在规格化的情况下，取值范围1<M<(2-ε)
正因为如此，我们才需要对原始的整数二进制表示做偏移，偏移多少呢？偏移2E。
这个“E”怎么算？上面的239怎么得来的呢？浮点数表示中的8位指数为就是告诉这个的。我们知道：
E = e-Bias
那么根据指数位:
101001102=>16610
即e=166，由此算出E=e-Bias=166-127=39，就是说将整数二进制表示转为标准的浮点数二进制表示的时候需要将小数点左移39位，好，我们现在把它还原得到整数的二进制表示：
1 00000000100110100111110 0000000000000000
1│←───── 23─────→│← 16─→│
23+16=39，后面接着就是小数点了。
拿出计算器，输入二进制数1000000001001101001111100000000000000000
转为十进制数，不正是：551051722752么！
前C/C++编译器标准都遵照IEEE制定的浮点数表示法来进行float,double运算。这种结构是一种科学计数法，用符号、指数和尾数来表示，底数定为2——即把一个浮点数表示为尾数乘以2的指数次方再添上符号。下面是具体的规格：
符号位 阶码 尾数 长度
float 1 8 23 32
double 1 11 52 64
以下通过几个例子讲解浮点数如何转换为二进制数
例一：
已知：double类型38414.4。
求：其对应的二进制表示。
分析：double类型共计64位，折合8字节。由最高到最低位分别是第63、62、61、……、0位：
最高位63位是符号位，1表示该数为负，0表示该数为正；
62-52位，一共11位是指数位；
51-0位，一共52位是尾数位。
步骤：按照IEEE浮点数表示法，下面先把38414.4转换为十六进制数。
把整数部和小数部分开处理:整数部直接化十六进制：960E。小数的处理:
0.4=0.5*0+0.25*1+0.125*1+0.0625*0+……
实际上这永远算不完！这就是著名的浮点数精度问题。所以直到加上前面的整数部分算够53位就行了。隐藏位技术：最高位的1不写入内存（最终保留下来的还是52位）。
如果你够耐心，手工算到53位那么因该是：38414.4(10)=1001011000001110.0110011001100110011001100110011001100(2)
科学记数法为：1.001011000001110 0110011001100110011001100110011001100，右移了15位，所以指数为15。或者可以如下理解：
1.001011000001110 0110011001100110011001100110011001100×2^15
于是来看阶码，按IEEE标准一共11位，可以表示范围是-1024 ~ 1023。因为指数可以为负，为了便于计算，规定都先加上1023(2^10-1)，在这里，阶码：15+1023=1038。二进制表示为：100 00001110；
符号位：因为38414.4为正对应 为0；
合在一起（注：尾数二进制最高位的1不要）：
01000000 11100010 11000001 110 01100 11001100 11001100 11001100 11001100
例二：
已知：整数3490593(16进制表示为0x354321)。
求：其对应的浮点数3490593.0的二进制表示。
解法如下：
先求出整数3490593的二进制表示：
H: 3 5 4 3 2 1 （十六进制表示）
B: 0011 0101 0100 0011 0010 0001 （二进制表示）
│←───── 21────→│
即：
1.1010101000011001000012×221
可见，从左算起第一个1后有21位，我们将这21为作为浮点数的小数表示，单精度浮点数float由符号位1位，指数域位k=8位，小数域位(尾数)n=23位构成，因此对上面得到的21位小数位我们还需要补上2个0，得到浮点数的小数域表示为：
1 0101 0100 0011 0010 0001 00
float类型的偏置量Bias=2k-1-1=28-1-1=127，但还要补上刚才因为右移作为小数部分的21位，因此偏置量为127+21=148，就是IEEE浮点数表示标准：
V = (-1)s×M×2E
E = e-Bias
中的e，此前计算Bias=127，刚好验证了E=148-127=21。
将148转为二进制表示为10010100，加上符号位0，最后得到二进制浮点数表示1001010010101010000110010000100，其16进制表示为：
H: 4 A 5 5 0 C 8 4
B: 0100 1010 0101 0101 0000 1100 1000 0100
|←──── 21 ─────→ |
1|←─8 ─→||←───── 23 ─────→ |
这就是浮点数3490593.0(0x4A550C84)的二进制表示。
例三：
0.5的二进制形式是0.1
它用浮点数的形式写出来是如下格式
0 01111110 00000000000000000000000
符号位 阶码 小数位
正数符号位为0，负数符号位为1
阶码是以2为底的指数
小数位表示小数点后面的数字
下面我们来分析一下0.5是如何写成0 01111110 00000000000000000000000
首先0.5是正数所以符号位为0
再来看阶码部分,0.5的二进制数是0.1,而0.1是1.0*2^(-1),所以我们总结出来:
要把二进制数变成(1.f)*2^(exponent)的形式,其中exponent是指数
而由于阶码有正负之分所以阶码=127+exponent;
即阶码=127+(-1)=126 即 01111110
余下的小数位为二进制小数点后面的数字,即00000000000000000000000
由以上分析得0.5的浮点数存储形式为0 01111110 00000000000000000000000
注：如果只有小数部分,那么需要右移小数点. 比如右移3位才能放到第一个1的后面, 阶码就是127-3=124.
例四 （20.59375）10 =（10100.10011 ）2
首先分别将整数和分数部分转换成二进制数：
20.59375＝10100.10011
然后移动小数点，使其在第1，2位之间
10100.10011＝1.010010011×2^4 即e＝4
于是得到：
S＝0， E＝4＋127＝131， M＝010010011
最后得到32位浮点数的二进制存储格式为：
0100 1001 1010 0100 1100 0000 0000 0000＝(41A4C000)16
例五：
-12.5转为单精度二进制表示
12.5:
1. 整数部分12，二进制为1100; 小数部分0.5, 二进制是.1，先把他们连起来，从第一个1数起取24位（后面补0）：
1100.10000000000000000000
这部分是有效数字。（把小数点前后两部分连起来再取掉头前的1，就是尾数）
2. 把小数点移到第一个1的后面，需要左移3位（1.10010000000000000000000*2^3）, 加上偏移量127：127+3=130，二进制是10000010，这是阶码。
3. -12.5是负数，所以符号位是1。把符号位，阶码和尾数连起来。注意，尾数的第一位总是1，所以规定不存这一位的1，只取后23位：
1 10000010 10010000000000000000000
把这32位按8位一节整理一下，得：
11000001 01001000 00000000 00000000
就是十六进制的 C1480000.
例六：
2.025675
1. 整数部分2，二进制为10; 小数部分0.025675, 二进制是.0000011010010010101001，先把他们连起来，从第一个1数起取24位（后面补0）：
10.0000011010010010101001
这部分是有效数字。把小数点前后两部分连起来再取掉头前的1，就是尾数: 00000011010010010101001
2. 把小数点移到第一个1的后面，左移了1位, 加上偏移量127：127+1=128，二进制是10000000，这是阶码。
3. 2.025675是正数，所以符号位是0。把符号位，阶码和尾数连起来：
0 10000000 00000011010010010101001
把这32位按8位一节整理一下，得：
01000000 00000001 10100100 10101001
就是十六进制的 4001A4A9.
例七：
(逆向求十进制整数)一个浮点二进制数手工转换成十进制数的例子：
假设浮点二进制数是 1011 1101 0100 0000 0000 0000 0000 0000
按1，8，23位分成三段：
1 01111010 10000000000000000000000
最后一段是尾数。前面加上"1.", 就是 1.10000000000000000000000
下面确定小数点位置。由E = e-Bias，阶码E是01111010，加上00000101才是01111111（127），
所以他减去127的偏移量得e=-5。（或者化成十进制得122，122-127=-5）。
因此尾数1.10（后面的0不写了）是小数点右移5位的结果。要复原它就要左移5位小数点，得0.0000110, 即十进制的0.046875 。
最后是符号：1代表负数，所以最后的结果是 -0.046875 。
注意：其他机器的浮点数表示方法可能与此不同. 不能任意移植。
再看一例(类似例七)：
比如：53004d3e
二进制表示为：
01010011000000000100110100111110
按照1个符号 8个指数 23个小数位划分
0 10100110 00000000100110100111110
正确的结果转出来应该是551051722752.0
该怎么算？
好，我们根据IEEE的浮点数表示规则划分，得到这个浮点数的小数位是：
00000000100110100111110
那么它的二进制表示就应该是：
1.000000001001101001111102 × 239
这是怎么来的呢？ 别急，听我慢慢道来。
标准化公式中的M要求在规格化的情况下，取值范围1<M<(2-ε)
正因为如此，我们才需要对原始的整数二进制表示做偏移，偏移多少呢？偏移2E。
这个“E”怎么算？上面的239怎么得来的呢？浮点数表示中的8位指数为就是告诉这个的。我们知道：
E = e-Bias
那么根据指数位:
101001102=>16610
即e=166，由此算出E=e-Bias=166-127=39，就是说将整数二进制表示转为标准的浮点数二进制表示的时候需要将小数点左移39位，好，我们现在把它还原得到整数的二进制表示：
1 00000000100110100111110 0000000000000000
1│←───── 23─────→│← 16─→│
23+16=39，后面接着就是小数点了。
拿出计算器，输入二进制数1000000001001101001111100000000000000000
转为十进制数，不正是：551051722752么！
c090869 2012-05-31
- 打赏
- 举报
为了感谢lz对IEEE754的精彩介绍，不要LZ的分。，
因为在内存中指数部分所存的指数的值都是非负数，为了表达一个较小的数，
比如 0.00001,就需要它的指数的值为负数，所以要设一个偏移量，
使指数的值在 127~ -127 之间。
因为在内存中指数部分所存的指数的值都是非负数，为了表达一个较小的数，
比如 0.00001,就需要它的指数的值为负数，所以要设一个偏移量，
使指数的值在 127~ -127 之间。
加载更多回复（3）
