C++中浮点数在内存中的表示

复制了两篇文章的内容：

http://blog.csdn.net/nethibernate/article/details/6120382

http://www.cnblogs.com/dolphin0520/archive/2011/10/02/2198280.html

也是由一道题目引出的问题：

#include <stdio.h>int main(){printf("%f\n",5);printf("%d",5.01);}

第一个printf打印出的结果应该是不可预期的，第二个printf打印的应该是一个很大的数。下面是在gcc中的输出。

下面分析一下原因。首先需要明白整型数据和浮点型数据在内存中的表示方法。有一篇文章说的很清楚：

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

先说一下计算机中二进制的算法：

• 整数 
  整数的二进制算法大家应该很熟悉，就是不断的除以2取余数，然后将余数倒序排列。比如求9的二进制： 
  9/2=4 余 1 
  4/2=2 余 0 
  2/2=1 余 0 
  1/2=0 余 1 
  一直计算到商为0为止，然后将得到的余数由下到上排列，就得到了9的二进制：1001。 
  从上面的算法我们可以看到，用整数除以2，最终都能够到0。因此，整数是可以用二进制来精确表示的。

• 小数 
  小数的二进制算法和整数的大致相反，就是不断的拿小数部分乘以2取积的整数部分，然后正序排列。比如求0.9的二进制： 
  0.9*2=1.8 取 1 
  0.8*2=1.6 取 1 
  0.6*2=1.2 取 1 
  0.2*2=0.4 取 0 
  0.4*2=0.8 取 0 
  0.8*2=1.6 取 1 
  … … 
  如此循环下去。因此我么得到的二进制小数也是无限循环的：0.11100110011... 
  从小数的二进制算法中我们可以知道，如果想让这种算法停止，只有在小数部分是0.5的时候才可以，但是很不幸，这类的小数很少。所以大部分小数是很难用二进制来精确表示的。

------------------------我是分割线------------------------------ 

OK，有了上面的知识，我们进入正题：看看float类型在内存中是如何表示的。  
float类型又称为单精度浮点类型，在 IEEE 754-2008 中是这样定义它的结构的：

  S     EEEEEEEE      FFFFFFFFFFFFFFFFFFFFFFF
31   30        23    22                               0

 

float类型总共4个字节——32位：

1. 符号位
   其中最左边的为符号位，0为正，1为负。
2. 指数
   接下来的E是指数，一共8位，也用二进制来表示。
3. 尾数
   最后的F是小数部分，尾数正是由这23位的小数部分+1位组成的。（这个稍后解释）。

这里我们需要多说一下指数。虽然指数也是用8位二进制来表示的，但是IEEE在定义它的时候做了些手脚，使用了偏移来计算指数。

IEEE规定，在float类型中，用来计算指数的偏移量为127。也就是说，如果你的指数实际是0，那么在内存中存的就是0+127=127的二进制。稍后我们来看这个到底如何使用。

 

好了，看了这么多，我们该演示一下计算机如何将一个十进制的实数转换为二进制的。就拿6.9这个数字来举例吧。-_-||!

 

首先，我们按照上面说的方法，分别将整数和小数转换成对应的二进制。这样6.9的二进制表示就是110.1110011001100...。这里就看出来 了，6.9转换成二进制，小数部分是无限循环的，这在现在的计算机系统上是无法精确表示的。这是计算机在计算浮点数的时候常常不精确的原因之一。

 

其次，将小数点左移（或右移）到第一个有效数字之后。说的通俗些，就是把小数点移到第一个1之后。这样的话，对于上面的110.1110011001100...我们就需要把小数点左移2位，得到1.101110011001100...。

 

接下来的事情就有意思了。首先我们把得到的1.101110011001100..这个数，从小数点后第一位开始，数出23个来，填充到上面float内存 结构的尾数部分（就是那一堆F的地方），我们这里数出来的就是10111001100110011001100。这里又要发生一次不精确了，小数点后超出 23位的部分都将被舍弃，太惨了。

 

不过，这里有一个可能让大家觉得特别坑爹的事情，就是小数点前面的1也不要了。仔细看看上面的内存结构，确实没有地方存放这个1。原因是这样的：IEEE觉 得，既然我们大家都约定把小数点移动到第一个有效数字之后，那也就默认小数点前面一定有且只有一个1，所以把这个1存起来也浪费，干脆就不要了，以后大家 都这么默契的来就好。这也是为什么我上面说尾数是23位+1位的原因。

 

填充完尾数，该填充指数了。这个指数就是刚才我们把小数点移动的位数，左移为正，右移为负，再按照上面所说的偏移量算法，我们填充的指数应该是2+127=129。转换成8位二进制就是10000001。

 

最后，根据这个数的正负来填充符号位。我们这里是正数，所以填0。这样6.9的在内存中的存储结果就出来了：

0  10000001  10111001100110011001100

 

总结一下，实数转二进制float类型的方法：

A. 分别将实数的整数和小数转换为二进制
B. 左移或者右移小数点到第一个有效数字之后
C. 从小数点后第一位开始数出23位填充到尾数部分 
D. 把小数点移动的位数，左移为正，右移为负，加上偏移量127，将所得的和转换为二进制填充到指数部分
E. 根据实数的正负来填充符号位，0为正，1为负

如果需要把float的二进制转换回十进制的实数，只要将上面的步骤倒着来一边就行了。

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

另一篇文章的例子：

下面举例说明：

float型数据125.5转换为标准浮点格式

125二进制表示形式为1111101，小数部分表示为二进制为 1，则125.5二进制表示为1111101.1，由于规定尾数的整数部分恒为1，则表示为1.1111011*2^6，阶码为6，加上127为133，则表示为10000101，而对于尾数将整数部分1去掉，为1111011，在其后面补0使其位数达到23位，则为11110110000000000000000

则其二进制表示形式为

0 10000101 11110110000000000000000，则在内存中存放方式为：

00000000   低地址

00000000

11111011

01000010   高地址

而反过来若要根据二进制形式求算浮点数如0 10000101 11110110000000000000000

由于符号为为0，则为正数。阶码为133-127=6，尾数为11110110000000000000000，则其真实尾数为1.1111011。所以其大小为

1.1111011*2^6，将小数点右移6位，得到1111101.1，而1111101的十进制为125，0.1的十进制为1*2^(-1)=0.5，所以其大小为125.5。

同理若将float型数据0.5转换为二进制形式

0.5的二进制形式为0.1，由于规定正数部分必须为1，将小数点右移1位，则为1.0*2^(-1)，其阶码为-1+127=126，表示为01111110，而尾数1.0去掉整数部分为0，补齐0到23位00000000000000000000000，则其二进制表示形式为

0 01111110 00000000000000000000000

由上分析可知float型数据最大表示范围为1.11111111111111111111111*2^127=3.4*10^38

对于double型数据情况类似，只不过其阶码为11位，偏置量为1023，尾数为52位。

#include <iostream>using namespace std;int main(){float a=125.5;char *p=(char *)&a;printf("%d\n",*p);printf("%d\n",*(p+1));printf("%d\n",*(p+2));printf("%d\n",*(p+3));return 0;}

输出：

在上面已经知道float型125.5在内存中存放方式为：

00000000   低地址

00000000

11111011

01000010   高地址

因此对于p和p+1指向的单元，其中存储的二进制数表示的十进制整数为0；

而对于p+2指向的单元，由于为char型指针，为带符号的数据类型，因此11111011，符号位为1，则为负数，由于在内存中二进制是以补码存储的，所以其真值为-5.

对于p+3指向的单元，01000010，为正数，则其大小为66。上面程序输出结果验证了其正确性。

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

但是针对上面的测试程序，我还有个问题没有明白,就是这行代码：

char *p=(char *)&a;

这行代码的作用是使一个指向char类型的指针指向一个整型变量的地址，然后执行p+1的操作时指针是平移一个字节而不是4个字节。

这样在下面的printf函数中进栈的只是一个字节的内容。然后打印出来的就依次是浮点数在内存中从低地址到高地址的内容。

我的问题是参数进栈是一个字节的数据，但是依照"%d"格式应该是读取4个字节的数据，那么为什么读取的数据还是正确的？将"%d"的输出格式变成"%c"后答案就更奇怪了：

前两次函数调用时都直接输出了a，但是a的ansic码是97啊，0对于的字符应该是个空字符。

那么*p返回的类型到底是不是char类型的？

之所以会出现上面的困惑主要是以前看过这么一段代码：

#include <stdio.h>int main(){unsigned int a=0xFFFFFFF7;char * p=(char *)&a;printf("%08x",*p);return 0;}

它的输出结果是

就是说printf中参数*p进栈时明显是p所指向的那块内存区的unsigned int型的数据进栈了，虽然p是char类型的指针，但是当它指向的内存是int类型时，对p执行解引用(*操作)时返回的应该是int型数据，就是执行*p时访问了4个字节的内容。这就是指针的类型和指针所指向的数据的类型的区别。