32位浮点数最多能表示多少位十进制小数啊?为什么编程时只是显示六个小数位啊?

看不出来你怎么隔开的,但是有两点要求,一是e前后均有数字,且后面的必须是整数.二是小数点前后必须都有数字

1.27*10^15*3600*24=1.097*10^20

#include
int main()
{
float a, b, c;
printf("输入3个浮点数,以空格隔开:n");
scanf("%f %f %f", &a, &b, &c);
printf("平均值为: %.2f", (a+b+c)/3);
return 0;
}

1) 阶码：11…1,尾数：0.11…1.真值：2^(2^7)*(1-2^(-23))
2) 阶码：11…1,尾数：1.00…0.真值：2^(2^7)*(-1)
3) 范围：[2^(2^7)*(-1),2^(2^7)*(1-2^(-23))].

对阶
尾数运算
结果规格化
舍入处理
溢出判断

27=16+11
27/64=0001 1011*2^(-6)=1.1011*2^(-2)
s=1
E=-2+127=125=0111 1101
M=1011 0000 0000 0000 0000 000
结果为1 0111 1101 1011 0000 0000 0000 0000 000

"^(?!0*$)[0-9]+(\.(?=.*[1-9])[0-9]{1,8})?$"
所有正有理数,小数不能超过8位

D
为了便于计算机中小数点的表示,规定将浮点数写成规格化的形式,即尾数的绝对值大于等于0.1并且小于1,从而唯一规定了小数点的位置.
所以选择D,尾数的绝对值大于等于0.1并且小于1
浮点数表示方法：
在科学计算中,为了能表示特大或特小的数,采用"浮点数"或称"科学表示法"表示实数,"浮点数"由两部分组成,即尾数和阶码.例如,5.23456 ,则0.23456为尾数,5是阶码.
在浮点表示方法中,小数点的位置是浮动的,阶码可取不同的数值.为了便于计算机中小数点的表示,规定将浮点数写成规格化的形式,即尾数的绝对值大于等于0.1并且小于1,从而唯一规定了小数点的位置.尾数的长度将影响数的精度,其符号将决定数的符号.浮点数的阶码相当于数学中的指数,其大小将决定数的表示范围.

以下纯手打,如果你仔细读完应该就能彻底明白了.
首先,我觉得你应该已经掌握了浮点数表示的相关概念,否则你需要先读懂你的计算机组成原理教材...
下面说十进制怎么转换成二进制浮点数：
二进制里的小数和十进制一样,在转换成指数表示时只需要将尾数左移或右移,同时减或加指数即可.
所以一个十进制数若能够无精度损失地转换成二进制,则这个数在转换成最简分数时,它的分母必须为2的整数次幂（所有整数的分母为1,即2的0次幂）,这样就可以先将其整数分子用二进制表示（整数的数制转换当然是没有任何障碍的,小数点就紧接在最低位右边）,然后将这个二进制的分子右移那个2次幂分母的幂个数位即可.就像该题第一问的3.5,其实就是7/2,那么用二进制的111表示7,然后右移1位得11.1,就是它的二进制小数表示,再转换成规格化浮点数,就变成0.111x2^2.
但是,若某个数在转换成最简分数时,分母不是2的整数次幂,它就不能无精度损失地转换了.这个道理对10进制来说也同样成立,只有当一个分数的分母可以转换10的整数次幂时（当然,因为10并不是质数,所以此时的分数未必是最简的,如1/2要换成5/10,1/4要换成25/100）才可以无精度损失地转换成十进制小数,所以像1/3,1/7等就只能转换成无限循环,这就有了精度损失.虽然我在这里说小学生都懂的10进制确实有点啰嗦,但将一个分数“有损”地转换成二进制时也必须经过类似的步骤.例如第二问的-1/10000,先不考虑它的负号（这只与补码表示有关）,显然分母不能表示为2的整数次幂,但仍必须把这个10进制分母去掉,所以就只能乘以一个差不多大的2的整数次幂,即2^13=8192,然后1/10000就被近似为了1/8192,然后就可以像上一段说明的那样转换成二进制了.但这样的误差未免太大,为了减少误差,可以先把分子分母同时乘以若干倍,使放大后的分母非常接近2的某一整数次幂,然后替换（如将1000/1000000换成1049/2^20,这时的误差就很小了）,也可以直接把原数乘以一个非常大的2的整数次幂,比如1T即2^40,然后把小数点后4位直接丢掉,只保留整数部分转换成二进制然后右移40位.考虑到计算难度,我觉得各CPU芯片厂商采用的是第一种方法,但不论如何,浮点数的字长越长,精度就可以达到越高.如果你在编程时将某些经过除法运算后的逻辑上应是整数的浮点数多print几位,你就会发现在小数点后若干个0之后会多出一些很奇怪的数字.总之,类似第二问的数不能无精度损失地转换成二进制浮点,如果你要写一个“有损”的,像我说的方法随便写一个就可以了,因为这取决于具体的近似方法,所以是没有标答的（但请记得尾数要用补码表示）.
然后来说第三问.所有的整数都可以“无损”地转换成二进制,但这个数比较大（大于2^30）,已经超出了4位阶码能够表示的最大数(1-2^(-10))x2^(2^4-1),所以是完全无法表示的.说到这里,顺便补充一下,因为尾数和阶码均有字长限制,所以即使是表示范围内的数也可能产生精度损失,如2^14+16,由于在规格化时最低位在小数点后第11位,已超出了尾数字长,所以后面加上的16会完全丢失,而只剩下2^14.

规格化： x = -0.1101x2^-2
.
[阶数]原 = 10010b
[阶数]反 = 11101b
[阶数]移 = 01110b
.
[尾数]原 = 1.110100b
[尾数]反 = 1.001011b
[尾数]补 = 1.001100b
.
阶码 尾数
_____ ______
浮力表示： 01110 1001100b = 74Ch ,选答案 A

现在一般认为整数和浮点数运算差不多,都是通过硬件完成.(整数还是快点)
为什么一般情况下整数运算比浮点数运算更快?
主要是数表示的原因:
整数:正数是原码,负数是补码,加法可以直接相加,乘法也可以很快完成
浮点数:第一位是符号位,表示正负,然后是阶码(用移码表示),有若干位,最后的是尾数(用原码表示)
很明显,浮点数的加法运算首先要进行对位,就是把阶码变得一致,然后再按整数相加,最后再作调整,成为规范数,当然比整数慢了,整数就直接相加,乘法的原理也差不多,除了尾数,还要对阶码进行考虑

浮点数规格是 1.x 2^n
当相加大于1.即 这一部分为十进制的 2.时需要重新换算成十进制1.的形式

double number[SIZE]={0.0,1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8,9.9};
double* nPtr;
printf("c)");
for(int icnt=0;icnt!=10;++icnt)
{
printf("%.1f ",number[icnt]);
}
nPtr=number;
nPtr=&number[0];
printf("ne)");
for(int icnt=0;icnt!=10;++icnt)
{
printf("%.1f ",*(nPtr+icnt));
}
printf("nf)");
for(int icnt=0;icnt!=10;++icnt)
{
printf("%.1f ",*(number+icnt));
}
printf("ng)");
for(int icnt=0;icnt!=10;++icnt)
{
printf("%.1f ",nPtr[icnt]);
}
printf("nh) %.1f %.1f %.1f %.1f ",number[3],*(number+3),nPtr[3],*(nPtr+3));//1003664->8.8
printf("ni) %d->%.1f",nPtr+8,*(nPtr+8));
nPtr=&number[5];
nPtr-=4;
printf("nj) %d->%.1f",nPtr,*nPtr);//1003608->1.1

#include
#include
double round(double& x,int n) //对x四舍五入保留n为小数
{
double t1,t2=modf(x,&t1);
double t3=pow(10,n);
long t4=long(t2*t3+0.5);
x=t1+t4/t3;
return x;
}
void main(){
double x=1.53546;
double y1=x,y2=x,y3=x,y4=x;
round(y1,0); //对y1四舍五入保留0为小数
round(y2,1); //对y2四舍五入保留1为小数
round(y3,2); //对y3四舍五入保留2为小数
round(y4,3); //对y4四舍五入保留3为小数
cout

[vb.net]
Console.WriteLine("请输入半径")
Dim str = Console.ReadLine()
Dim r = 0.0
If Double.TryParse(str,r) Then
Console.WriteLine("半径={0},面积是:{1}",r,3.1415926 * r * r)
Else
Console.WriteLine("亲~!非数字!")
End If
----[c#.net]
Console.WriteLine("请输入半径");
var str = Console.ReadLine();
var r = 0.0;
If (Double.TryParse(str,r) )
Console.WriteLine("半径={0},面积是:{1}",r,3.1415926 * r * r);
Else
Console.WriteLine("亲~!非数字!");

就像 如果 A 这个字符 你按 %d 输出 是个数字 %C 输出是个字符一样, 一个数据存储都是按二进制形式存储,通过不同的方式,读出来的结果就不同.至于这个方式嘛,那是很底层的东西,如果你很想搞懂的话,可以看本叫《深入理解计算机》的书,你就可以知道怎么用计算机的方式思考,计算了.

浮点数是属于有理数中某特定子集的数的数字表示,在计算机中用以近似表示任意某个实数.具体的说,这个实数由一个整数或定点数（即尾数）乘以某个基数（计算机中通常是2）的整数次幂得到,这种表示方法类似于基数为10的科学记数法.
由此可以看出,在计算机中表示一个浮点数,其结构如下：
尾数部分（定点小数） 阶码部分（定点整数）
数符± 尾数m 阶符± 阶码e
这种设计可以在某个固定长度的存储空间内表示定点数无法表示的更大范围的数.
一个浮点数a由两个数m和e来表示：a = m × b^e.在任意一个这样的系统中,我们选择一个基数b（记数系统的基）和精度p（即使用多少位来存储）.m（即尾数）是形如±d.ddd...ddd的p位数（每一位是一个介于0到b-1之间的整数,包括0和b-1).如果m的第一位是非0整数,m称作规格化的.有一些描述使用一个单独的符号位(s 代表+或者-）来表示正负,这样m必须是正的.e是指数.
先澄清一个概念,浮点数并不一定等于小数,定点数也并不一定就是整数.所谓浮点数就是小数点在逻辑上是不固定的,而定点数只能表示小数点固定的数值,具用浮点数或定点数表示某哪一种数要看用户赋予了这个数的意义是什么.
C++中的浮点数有6种,分别是：
float：单精度,32位
unsigned float：单精度无符号,32位
double：双精度,64位
unsigned double：双精度无符号,64位
long double：高双精度,80位
unsigned long double：高双精度无符号,80位
123 2e4.2 .e5 -e3 .234 1e3 这几个数都有可能是浮点数!

最大正数(1-2^-7)x2^7=127
最小负数（-1)x(1-2^-7)x2^7=-127
非零最小正数(1-2^-1)x2^-8=0.001953125
最大负数（-1)x(1-2^-1)x2^-8=-0.001953125

-27/64：
尾符：这是负数,为1
27/64写成二进制位 0.011011=0.110110*2^-1,规格化要求尾数表示为0.1xxx的形式
阶符：为负数 1
阶码：-001的补码是111
尾码:用原码表示比较简单：110110
如果按照“阶符 阶码 尾符 尾码”表示,则应该表示为：
1 111 1 110110
写得比较乱,

C
机器中表示一个浮点数时需要给出指数,这个指数用整数形式表示,这个整数叫做阶码
阶码就是指数

阶码部分（8位）的表示范围是-128-127
因为整数在计算机里是用补码表示的.8位整数表示的范围是-128-127
用补码表示时+0,-0,是相同的,所以可以多表示一个数
用原码可以表示的是-127-(-0),+0-127

数符为0,这个数就是正数,正数补码就是其本身,其最高有效位(阶码使用标准移码的话规格化后尾数最高有效位就是小数点后第一位)必定为1,数符0和最高有效位的1相异.
数符为1,这个数就是个负数,求负数的补码有一步叫按位取反(一般来说浮点数可以存储的有效位不会小于6位),原本最高有效位的1变成了0,所以数符1和最高有效位的0相异.

三句话没有矛盾。
前面一句是给移码运算作一个定义，而实际移码运算是按照后面说的n位定点整数方法运算的。
再后面一句说的是移码运算和补码运算的关系。
注意：定点整数和IEEE754偏移值不一样。
定点整数的偏移值是2的（n-1）次幂，8位数的偏移值是128；
IEEE754偏移值是127。所以结果除了符号位不同外，绝对值也差1。

D

解答第1题：
.
x =22/64 =10110b/2^6
将10110b右移6位：
x = 0.010110b
规格化：x =0.10110bx(2^-1)
[x阶]原 =1001b
[x阶]反 =1110b
[x阶]补 =1111b
[x尾]补 =01011b
x浮 =1111,01011b
.
y = -2.75 = -(2+3/4) = -(10b +0.11b) = -10.11b
规格化：y = -0.1011bx(2^2)
[y阶]补 =0010b
[y尾]原 =11011b
[y尾]反 =10100b
[y尾]补 =10101b
y浮 =0010,10101b
.

正确的浮点数 是 .62 , 就是答案B, 允许小数点前省去0
A. e3 是标识符. 1e3 就对了
C. 2e4.5 指数必须是整数, 2e4 就对了
D. 123 是整型数.

因为浮点数字长 32 位； 其中阶码8 位,含1 位阶符.
补码表示,R=2； 尾数24 位,含1 位数符,补码表示； 规格化.
则其绝对值最小负数为4

选B和D
A中0.12是合法的
C中123e4和0.0是合法的

别找了没的

阶码3位,带符号位,则阶码最大为0111 (7),
尾数8为带符号说明尾数最大为+0.1111111.
故最大正数为0.1111111*2^7=01111111 (2^7-1)
哎,你居然不上线,害我白白回答了

C土壤会排斥NO3-

原始数值：+0.0011011
规格化后：+1.1011 × 2^(-3)要求格式：数符+阶符+阶码+尾数要求格式：x+y+zz+nnnnnn数符为正,即0；阶符为负,即1；阶码为3,即11；尾数为101100；最终结果：0 1 11 101100.

应该是二进制法则得出来的

《计算机组成原理》试题-1
一、单项选择题（在每小题的四个备选答案中，选出一个正确的答案，并将其代码填在题干后的括号内。每小题1分，共15分）
1.若十进制数据为137.5则其八进制数为（ ）。
A、89.8 B、211.4 C、211.5 D、1011111.101
2.若x补=0.1101010，则x原=（ ）。
A、1.0010101 B、1.0010...

没有为什么，书上就是这么写的。这是死记硬背的知识
采纳哦

十六进制数不能和字符串相加.
字符串转换成十六进制数后结果为：162170456（10进制）
字符串转换成十进制数后结果为：162170432（10进制）

0x42150000
data = (S)*(D)*(2^(E-127))
37.25 = 149/4
=> 10010101 >> 2
=> 1.0010101

化为2进制是整数部分除以二知道变为1 小数部分乘以2直到变为1 ,符号位0表示正1表示负
正数：原码=补码
负数：
原码 = 正数部分（去掉负号）的二进制值,且符号位（最左边的比特位）为1
反码 = 正数部分（去掉负号）的二进制值,按位取反
补码 = 反码 + 1
小数点依旧用点
定点数
所谓定点数是指小数点位置固定不变的数.在计算机中,通常用定点数来表示整数与纯小数,分别称为定点整数与定点小数.
定点整数：一个数的最高二进制位是数符位,用以表示数的符号；而小数点的位置默认为在最低(即最右边）的二进制位的后面,但小数点不单独占一个二进制位,如下所示:
0 1001010010001010001
数符位 数值位 小数位
因此,在一个定点整数中,数符位右边的所有二进制位数表示的是一个整数值.
定点小数：一个数的最高二进制位是数符位,用来表示数的符号；而小数点的位置默认为在数符位后面,不单独占一个二进制位,如图所示：
0 1001010010001010001
数符位|小数位 数值位
因此,在一个定点小数中,数符位右边的所有二进制位数表示的是一个纯小数.
2．浮点数
在计算机中,定点数通常只用于表示整数或纯小数.而对于既有整数部分又有小数部分的数,由于其小数点的位置不固定,一般用浮点数表示.
在计算机中所说的浮点数就是指小数点位置不固定的数.一般地,一个既有整数部分又有小数部分的十进制数D可以表示成如下形式:
D＝R*10N
其中R为一个纯小数,N为一个整数.
如一个十进制数123.456可以表示成：0.123456*103,十进制小数0.00123456可以表示成0.123456*10-2.纯小数R的小数点后第一位一般为非零数字.
同样,对于既有整数部分又有小数部分的二进制数口也可以表示成如下形式：
D＝R*2N
其中R为一个二进制定点小数,称为D的尾数；N为一个二进制定点整数,称为D的阶码,它反映了二进制数D的小数点的实际位置.为了使有限的二进制位数能表示出最多的数字位数,定点小数R的小数点后的第一位（即符号位的后面一位）一般为非零数字（即为“1”）.
在计算机中,通常用一串连续的二进制位来存放二进制浮点数,它的一般结构如图所示：
阶符 N 数符 R
| 阶码部分 | 小数位 尾数部分

看它是怎么约定的编码了.如果按照现在常用的方法来说,应该可以表示绝对值在(1+1/1024)/32~(2-1/1024)*32的范围内的数.

如果是整型除以整型,如int 1除以 int 2输出就是int 0,如果是 float 1 除以 int 2输出就是 float 0.5.
在c和c#中,结果的类型就是除数和被除数中最大那个类型 ,比如float比int大,即float占的字节数比int大.double比float大,long比int大

三个选项里都有不合法的
A中5e-9.4不合法,我不确定+1e+1是不是合法,我也正在查询它
B中-60不合法
C中123e不合法

理论上应该可以,运行一下试试看

是的!1为正,0为负!

参见IEEE 754编码标准
0.84这个来说
0.84×2 = 1.68 那么二进制小数部分第一位为1
0.68×2 = 1.36 那么二进制小数部分第二位为1
0.36×2 = 0.72 那么二进制小数部分第三位为0
..
一直继续下去直到得到23位 二进制小数（0.1 10101110000101000111101）
正数的符号位为0,
小数点右移一位,得到1 .10101110000101000111101 那么 exponent位-1 （-1+127=126 biased form）126二进制为01111110
所以0-01111110-10101110000101000111101=3F570A3DH
再看100.0整数部分100=64H=01100100
小数部分为0,
小数点左移6位1.100100,exponent 6+127=133=85H=10000101
0-10000101-10010000000000000000000=42C80000H

第一题：算法用C语言表示如下：
int p(int n){
if(n > 1){
return a*p(n-1);
}else {
return a;
}
}
其它的分析解决如下：
具有511个结点的满二叉树,其叶结点个数为( 512 )
分析：理解满二叉树的定义之后,你可以自己发现规律.即如果节点数为K则中结点数为K+1.
在n个顶点的有向完全图中,边的条数为（ ）
分析：有向完全图意思就是,图中的每一个点都有从自己开始到另外任意一个点的一条边.
所以容易得出边数是：2C(n,2) = n*(n-1)条边!
数组是通过（ 下标 ）进行索引
：数组使用方法一般为a[index]这种方式,index就是下标.

[例1]若浮点数x的754标准存储格式为（41360000）16,求其浮点数的十进制数值.
将16进制展开后,可得二进制数格式为
0 100,0001,0 011,0110,0000,0000,0000,0000
S E M
指数e=100,0001,0－01111111=00000011=（3）10
包含隐藏位1的尾数1.M=1.011,0110,0000,0000,0000,0000
于是有 x=（-1）^0*（1.M）*2^（E-127）
=+（1.011011）2*2^3
=（11.375）10

有四种表示方法：
原码：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^阶码位数 ＋ 真值（真值：指原来那个‘帯符号数’,注意要把把正副号带入计算）

因为题中明文指出了"非规格化".
我判断选c...

阶码为1110：对应值二进制补码为0110b,十进制为6
尾数为0010 1000 0000,即去掉首位符号为后值为：0.010 1000 0000
将尾数的小数点右移位后,值为0010 100.0 0000,对应二进制为：10100,十进制为：20