基恩士浮点数存储方式

㈠ 请问浮点型数据在计算机是怎么存储的

对于浮点类型的数据采用单精度类型（float）和双精度类型(double)来存储，float数据占用32bit，double数据占用64bit。

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

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

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

3、尾数部分（Mantissa）：尾数部分。

(1)基恩士浮点数存储方式扩展阅读

实型变量分为两类：单精度型和双精度型，

其类型说明符为float 单精度说明符，double
双精度说明符。在Turbo
C中单精度型占4个字节（32位）内存空间，其数值范围为3.4E-38～3.4E+38，只能提供七位有效数字。

双精度型占8
个字节（64位）内存空间，其数值范围为1.7E-308～1.7E+308，可提供16位有效数字。

实型变量说明的格式和书写规则与整型相同。

例如： float x,y; (x,y为单精度实型量)

double a,b,c; (a,b,c为双精度实型量)

实型常数不分单、双精度，都按双精度double型处理。

㈡ 浮点类型是如何存储的

计算机中最小的存储单位是bit只能保存0和1，整数在内存中如何存储我们都知道，将要存储的数字转成2进制即可

用windows自带的计数器可以方便的查看整数对应的2进制值
如：
byte类型（单字节）

那浮点类型是如何用这么少的字节（如float 4字节）表示这么大（float 最大 3.4028235E38）的数字呢？

浮点数，是属于有理数中某特定子集的数的数字表示，在计算机中用以近似表示任意某个实数。具体的说，这个实数由一个整数或定点数（即尾数）凳凳乘以某个基数（计算机中通常是2）的整数次幂得到，这种表示方法类似于基数为10的科学计数法。

科学计数法是一种记数的方法。把一个数表示成a与10的n次幂相乘的形式（1≤|a|<10，a不为分数形式，n为整数），这种记数法叫做科学计数法。当我们要标记或运算某个较大或较小且位数较多时，用科学计数法免去浪费枣核旅很多空间和时间。

这也是一种目前最常用的浮点数标准！为许多CPU与浮点运算器所采用。

简单的说就是将一个浮点数字拆成3个部分（符号部分、指数部分、小数部分） 存储在连续的bit中，类似科学计数法。

用 {S，E，M}来表示一个数 V 的，即 V =（-1）S × M × 2E ，如下：

其中：

其中d.dd...d 为有效数字，β为基数，e 为指数

有效数字中 数字的个数 称为 精度 ，我们可以用 p 来表示氏兄，即可称为 p 位有效数字精度。
每个数字 d 介于 0 和基数 β 之间，包括 0。

对十进制的浮点数，即基数 β 等于 10 的浮点数而言，上面的表达式非常容易理解。
如 12.34，我们可以根据上面的表达式表达为：
1×10 ¹ + 2×10 ⁰ + 3×10 ^-1 + 4×10 ^-2
其规范的浮点数表达为： 1.234×10 ¹ 。

但对二进制来说，上面的表达式同样可以简单地表达。
唯一不同之处在于：二进制的 β 等于 2，而每个数字 d 只能在 0 和 1 之间取值。

如二进制数 1001.101 ，我们可以根据上面的表达式表达为：
1×2 ³ + 0×2 ² + 0×2 ¹ + 1×2 ⁰ + 1×2 ^-1 + 0×2 ^-2 + 1×2 ^-3
其规范浮点数表达为： 1.001101×2 ³ 。

二进制数 1001.101 转成十进制如下：

由上面的等式，我们可以得出：
向左移动二进制小数点一位相当于这个数除以 2，而向右移动二进制小数点一位相当于这个数乘以 2。
如 101.11 = 5又3/4 (5.75)，向左移动一位，得到 10.111 = 2又7/8 （2.875）。

除此之外，我们还可以得到这样一个基本规律：
一个十进制小数要能用浮点数精确地表示，最后一位必须是 5（当然这是必要条件，并非充分条件）。
如下面的示例所示：

基本换算方法：
将10进制的数拆分成整数和小数两个部分
整数部分除以2，取余数；小数部分乘以2，取整数位。

示例：
将十进制 1.1 转成 二进制

整数部分：1
1

小数部分：0.1

二进制形式表示为：
1.000110011001100110011...

再加上整数1，约等于：
1.099609375

计算的位数越多越精确

注意：
二进制小数不像整数一样，只要位数足够，它就可以表示所有整数。
在有限长度的编码中，二进制小数一般无法精确的表示任意小数，比如十进制小数0.2，我们并不能将其准确的表示为一个二进制数，只能增加二进制长度提高表示的精度。

根据 IEEE 754 浮点“双精度格式”位布局。

如果参数是正无穷大，则结果为 0x7ff0000000000000L。
如果参数是负无穷大，则结果为 0xfff0000000000000L。
如果参数是 NaN，则结果为 0x7ff8000000000000L。

根据 IEEE 754 浮点“单一格式”位布局。

如果参数为正无穷大，则结果为 0x7f800000。
如果参数为负无穷大，则结果为 0xff800000。
如果参数为 NaN，则结果为 0x7fc00000。

这里以 double类型说明

将一个浮点数与上面的掩码进行与运算，即可得到对应的 符号位、指数位、尾数位 的值。

1.000110011001100110011...

所以存为：
0 01111111111 000110011001100110011...

根据 IEEE 754 规范

在二进制，第一个有效数字必定是“1”，因此这个“1”并不会存储。
单精和双精浮点数的有效数字分别是有存储的23和52个位，加上最左边没有存储的第1个位，即是24和53个位。

通过计算其能表示的最大值，换十进制来看其精度：

浮点运算很少是精确的，只要是超过精度能表示的范围就会产生误差。而往往产生误差不是因为数的大小，而是因为数的精度。

我自己理解为分两种情况（这个不一定是对）

通过上面的转换示例，我们知道小数的二进制表示一般都不是精确的，在有限的精度下只能尽量的表示近似值

值本身就不是精确的，再进行计算就很可能产生误差

输出：

0.1
原始值： 0 01111111011
指数：1019 -1023 = -4
二进制形式：
0.0001

0.2
原始值：0 01111111100
指数：1020 -1023 = -3
二进制形式：
0.00

0.3
原始值：0 01111111101
指数：1021 = -2
二进制形式：
0.00

二进制加法运算

这里用float验证，float最大的精度是8位数

对于不能精确的表示的数，采取一种系统的方法：找到“最接近”的匹配值，它可以用期望的浮点形式表现出来，这就是舍入。

对于舍入，可以有很多种规则，可以向上舍入，向下舍入，向偶数舍入。如果我们只采用前两种中的一种，就会造成平均数过大或者过小，实际上这时候就是引入了统计偏差。如果是采用偶数舍入，则有一半的机会是向上舍入，一半的机会是向下舍入，这样子可以避免统计偏差。而 IEEE 754 就是采用向最近偶数舍入（round to nearest even）的规则。

（这段是网上抄的）

这里以java语言示例，用大端的方式示例（网络序）

java中是以大端模式存储的，java对我们屏蔽了内部字节顺序的问题以实现跨平台！

实际在不同的cpu架构下，存储方式不同，我们常用的X86是以小端的模式存储的。

网络传输一般采用大端序，也被称之为网络字节序，或网络序。IP协议中定义大端序为网络字节序。

输出：

㈢ 浮点数 在计算机内的存储形式

浮点数不难，但是要想记熟还真有点不容易，多琢磨琢磨。

一般情况下，浮点数的表示有一下几个要点：

1、要规格化（让浮点数表示结果唯一），因为100＝10^2 = 0.1 * 10^3, 所以第一步要统一地规格化，确定“阶数”和“尾数”（尾数在0.5－1之间，也就是二进制的0.1－1.0之间）

2、“阶码”一般用“移码”表示法，而“尾数”一般用“原码/补码表示法，“数符”表示浮点数的正副号

3、浮点数的形式： “符号位”【应该就是‘数符’】＋“阶码”＋“尾数“
－－浮点数的表示按照不同地标准，表示方法不同，你的原问题没讲清楚用什么格式表示，我就用最常用地格式来理解了
－－－－－－－－－－－－－－－－－－
其实就以上两点，计算机中“‘帯符号数’的表示”有四种：原码、补码、反码、移码，这些都是基础知识，可以自己去看一下这四种表示方法，就自然明白“阶符、数符”这些相当于“符号位”的作用了。

先简单讲一下吧，你再结合详细资料看吧：【设所表示的都是定点纯小数】
（小数点前面可以看成是“符号位”，也就对应原来地“阶符”和“数符”）
原码：0.11表示0.75（2^-1 + 2 ^-2）， 1.11表示 ‘－0.75’（前面的1相当于符号位，表示这个数是负数，也就是说“符号位是0”表示正数，1表示负数）

补码：最普遍地就是补码了 0.11表示0.75， 1.11表示‘-0.25’（也是“0”为正数，1为负数。和原码地规律一样）

反码，最简单了：正数不变，负数对每一位‘取反’即可，0.11＝0.75，1.10＝-0.25（即0.01地相反数）
－－－－－－－－－－－－－以上三种表示方法，对正数的情况都不做处理，但是移码表示法要对正数做处理。

移码：1.01＝0.25，而0.01＝-0.75
。移码复杂一点，他的表示方法是： 移码＝ 2^阶码位数 ＋ 真值（真值：指原来那个‘帯符号数’，注意要把把正副号带入计算）

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
N=－0.110101x2^100： 阶数是“正100”，尾数是“负0.110101”，所以整个浮点数是个负数，所以第一位是“1”【第一个符号位－“数符”表示‘尾数的正负号’】
阶码是“10 0100”【移码表示法，最高位是“符号位”】

所以，应该表示为： 1（符号位） 100100（阶码的移码表示） 11010100【尾数和符号位结合起来，用的是原码表示法】

㈣ 浮点数在计算机中的存储方式中，指数位为什么是采用“移位存储”方式怎么看出来是用“移位存储”

不论是float还是double在存储方式上都是遵从IEEE的规范的.
float遵从的是IEEE R32.24 ,而double 遵从的是R64.53。

浮点数保存的字节格式如下：

地址 +0 +1 +2 +3
内容 SEEE EEEE EMMM MMMM MMMM MMMM MMMM MMMM

这里
S 代表符号位，1是负，0是正
E 偏移127的幂，二进制阶码=(EEEEEEEE)-127。
M 24位的尾数保存在23位中，只存储23位，最高位固定为1。此方法用最较少的位数实现了
较高的有效位数，提高了精度。

零是一个特定值，幂是0 尾数也是0。

浮点数-12.5作为一个十六进制数0xC1480000保存在存储区中，这个值如下：
地址 +0 +1 +2 +3
内容0xC1 0x48 0x00 0x00

浮点数和十六进制等效保存值之间的转换相当简单。下面的例子说明上面的值-12.5如何转
换。
浮点保存值不是一个直接的格式，要转换为一个浮点数，位必须按上面的浮点数保存格式表
所列的那样分开，例如：

地址 +0 +1 +2 +3
格式 SEEE EEEE EMMM MMMM MMMM MMMM MMMM MMMM
二进制 11000001 01001000 00000000 00000000
十六进制 C1 48 00 00

从这个例子可以得到下面的信息：
符号位是1 表示一个负数
幂是二进制10000010或十进制130，130减去127是3，就是实际的幂。
尾数是后面的二进制数10010000000000000000000

在尾数的左边有一个省略的小数点和1,这个1在浮点数的保存中经常省略,加上一个1和小数
点到尾数的开头,得到尾数值如下:
1.10010000000000000000000

接着,根据指数调整尾数.一个负的指数向左移动小数点.一个正的指数向右移动小数点.因为
指数是3,尾数调整如下:
1100.10000000000000000000

结果是一个二进制浮点数，小数点左边的二进制数代表所处位置的2的幂，例如：1100表示
(1*2^3)+(1*2^2)+(0*2^1)+(0*2^0)=12。
小数点的右边也代表所处位置的2的幂，只是幂是负的。例如：.100...表示(1*2^(-1))+
(0*2^(-2))+(0*2^(-2))...=0.5。
这些值的和是12.5。因为设置的符号位表示这数是负的，因此十六进制值0xC1480000表示-
12.5。

下面给个例子

#include <stdio.h>
union FloatData
{
float f;
unsigned char h[4];
};
void main(void)
{
FloatData t;
float temp = 0;
printf(

㈤ float和double型分别怎么存储

C/C++的浮点数据类型有float和double两种。

类型float大小为4字节，即32位，内存中的存储方式如下： 符号位（1 bit） 指数（8 bit） 尾数（23 bit）

类型double大小为8字节，即64位，内存布局如下： 符号位（1 bit） 指数（11 bit） 尾数（52 bit）

符号位决定浮点数的正负，0正1负。

指数和尾数均从浮点数的二进制科学计数形式中获取。

如，十进制浮点数2.5的二进制形式为10.1，转换为科学计数法形式为(1.01)*(10^1)，由此可知指数为1，尾数（即科学计数法的小数部分）为01。

根据浮点数的存储标准（IEEE制定），float类型指数的起始数为127（二进制0111 1111），double类型指数的起始数为1023(二进制011 1111 1111)，在此基础上加指数，得到的就是内存中指数的表示形式。尾数则直接填入，如果空间多余则以0补齐，如果空间不够则0舍1入。所以float和double类型分别表示的2.5如下（二进制）：

符号位

指数

尾数

0

1000 0000

010 0000 0000 0000 0000 0000

0

100 0000 0000

0100 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000

㈥ 浮点数在计算机里面的存储

这个问题比较难..其实在实际运算过程中或写程序中我们要求的浮点数都有一定的精度,大多数情况下存成文件等形式我们一般会让他*10^n次方来存储去掉小数位.下面说正题.

何数据在内存中都是以二进制（0或1）顺序存储的，每一个1或0被称为1位，而在x86CPU上一个字节是8位。比如一个16位（2 字节）的short int型变量的值是1000，那么它的二进制表达就是：00000011 11101000。由于Intel CPU的架构原因，它是按字节倒序存储的，那么就因该是这样：11101000 00000011，这就是定点数1000在内存中的结构。
目前C/C++编译器标准都遵照IEEE制定的浮点数表示法来进行float,double运算。这种结构是一种科学计数法，用符号、指数和尾数来表示，底数定为2——即把一个浮点数表示为尾数乘以2的指数次方再添上符号。下面是具体的规格：
````````符号位 阶码 尾数 长度
float 1 8 23 32
double 1 11 52 64
临时数 1 15 64 80

由于通常C编译器默认浮点数是double型的，下面以double为例：
共计64位，折合8字节。由最高到最低位分别是第63、62、61、……、0位：
最高位63位是符号位，1表示该数为负，0正；
62-52位，一共11位是指数位；
51-0位，一共52位是尾数位。
按照IEEE浮点数表示法，下面将把double型浮点数38414.4转换为十六进制代码。
把整数部和小数部分开处理:整数部直接化十六进制：960E。小数的处理:
0.4=0.5*0+0.25*1+0.125*1+0.0625*0+……
实际上这永远算不完！这就是着名的浮点数精度问题。所以直到加上前面的整数部分算够53位就行了（隐藏位技术：最高位的1 不写入内存）。
如果你够耐心，手工算到53位那么因该是：38414.4(10)=1001011000001110.(2)
科学记数法为：1.001……乘以2的15次方。指数为15！
于是来看阶码，一共11位，可以表示范围是-1024 ~ 1023。因为指数可以为负，为了便于计算，规定都先加上1023，在这里， 15+1023=1038。二进制表示为：100 00001110
符号位：正—— 0 ！ 合在一起（尾数二进制最高位的1不要）：
01000000 11100010 11000001 11001101 01010101 01010101 01010101 01010101
按字节倒序存储的十六进制数就是：
55 55 55 55 CD C1 E2 40

㈦ 计算机是如何存储浮点数的(工作原理，实现方式)

计算机用二进制来表示数字，浮点数也是如此：
首先了解如何用二进制表示小数（也就是如何把十进制小数转化为二进制表示）：
举一个简单例子，十进制小数 10.625
1）首先转换整数部分：10 = 1010b
2）小数部分0.625 = 0.101b
(用“乘2取整法”：0.625*2=1.25,得第一位为1，0.25*2=0.5，得第二位为0，0.5*2=1， 得第三位为1，余下小数部分为零，就可以结束了)
3）于是得到 10.625=1010.101b
换个表示方式更加深入理解：
1*(10^1)+0*(10^0)+6*(10^-1)+2*(10^-2)+5*(10^-3) =
1*(2^3) + 0*(2^2) + 1*(2^1) + 0*(2^0) + 1*(2^-1) + 0*(2^-2) + 1*(2^-3)
4) 类似十进制可以用指数形式表示：
10.625=10625*（10^-3）
所得的二进制小数也可以这样指数形式表述：
1010.101b=1010101 * (2^-3)
也就是用有效数字a和指数e来表述： a * (2^e)
用一个32bit的空间（bit0~bit31）来存储这么一个浮点数，如此分配存储空间：
bit0 ~ bit22 共23bit，用来表示有效数字部分，也就是a，本例中a=1010101
bit23 - bit30 共8个bit，用来表是指数，也就是e，范围从-128到127，实际数据中的指数是原始指数加上127得到的，如果超过了127，则从-128开始计，所以这里e=-3表示为124
bit31 为符号位，1表示负数，这里应该为0
把上述结果填入32bit的存储器，就是计算机表示小数10.625的形式。

注意这个例子的特殊性：它的小数部分正好可以用有限长度的2进制小数表示，因此，而且整个有效数字部分a的总长度小于23，因此它精确的表示了10.625，但是有的情况下，有效数字部分的长度可能超过23，甚至是无限多的，那时候就只好把后面的位数截掉了，那样表示的结果就只是一个近似值而非精确值；显然，存储长度越长，精度就越高，比如双精度浮点数长度为64位，1位符号位，11位指数位，52位有效数字。

㈧ C语言浮点数的储存方式为何浮点数储存不准确那个图片是什么意思

C语言中，无论是单精度还是双精度在存储中都分为三个部分：
1. 符号位(Sign) : 0代表正，1代表为负
2. 指数位（Exponent）（注：也叫阶码）:用于存储科学计数法中的指数数据，并且采用移位存储（注：移码编码表示）
3. 尾数部分（Mantissa）：尾数部分
关于不精确是由于十进制小数部分化二进制，常常化不尽。如同无限循环小数，最后有截断误差。
图片中的是float型的变量的存储上的格式。

㈨ C/C++浮点数在内存中是怎么存储的

1. 把浮点数的绝对值的二进制表达的小数点移动到从左至右数第1个“1”之后，舍去1和小数点，把剩余的原码二进制0、1序列从左至右截取23(float型)或52(double型)位作为尾数。

2. 在尾数前添加8(float型)或11(double型)位用移码表示“制造”尾数时小数点移动的位数，叫阶码；阶码的最左那一位表示小数点移动的方向。

3. 在阶码前添加1位表示整个浮点数的正负，0表示大于等于0，1表示小于0。

4. 把这一串0、1序列在小端机上由右至左存储在某个地址开始的连续内存单元中，这“某个地址”就是承载这个浮点型数据的变量的地址。若在大端机上则将这一串0、1序列由左至右存放。
   

㈩ 浮点数的存储结构是怎样的

浮点数存储时有符号位，阶数位和尾数三部分组成。

解：最大的正数= (1-2 ^ (7))x 2 ^ (2 ^ (3) - 1) = (1-2 ^ (7)) x 2 ^(7) = 127，规则最小的正数＝2×2＾（－1）（或2＾（3））x＾2＝2－1＝2＾（8）（9）＝1／512。

最明显的绝对值是－1＊2＾（2＾3－1）也就是－1＊2＾7，也就是－128。

(10)基恩士浮点数存储方式扩展阅读：

浮点数A由两个数字m和e表示：A＝m＊b＾e。在任何这样的系统中，我们选择基数b（计数系统的基础）和精度p（要存储的比特数）。

M（即尾数）的形状陆雹为±d．dd…DDD的p位（每个位早尘帆是0和b－1之间的整数，包括0和b－1）。如果m的第一个数字是一个非零整数，那么m就被归一化了兄纤。

一些描述使用单个符号位（s表示＋或－）表示加号或减号，因此m必须是正数。E是a的指数。

结构：

表示计算机中的一个浮点数，其结构如下：

尾数部分（定点小数）指令码部分（定点整数）