c 浮点数 （转载）

小议c语言中的浮点数
还是hybrid sys的作业，写程序花了四个小时，调程序居然花了5个小时，最后是卡在浮点数的精度上了，写此文希望大家不要再犯和我一样的错误。

c语言里的浮点数虽然表示范围比较大，但却连一个精确的0.1都表示不了。不信？看看下面程序的结果：

#include "stdio.h"

main()
{
float a=1;
int i;

for(i=100;1>=0;i--)
a=a-0.01;
}

 

虽然误差很小，但在判断浮点数运算结果是不是为0时这点误差却能起决定性作用。解决方法有几总：

1、用一个区间代替0：

-0.001<a<0.001 

2、每次运算时加个尾数，比如需要做个时钟，当时间到时执行某项操作，那么每次不妨把t-0.1换成-0.1001，判断的条件改成t<0

3、换成整型运算。比如1.1换成11进行运算，要输出结果的时侯再除10就ok了

======================================
C语言深入(五) 浮点数的表示和计算
    用一个程序来说明浮点数的IEEE表示。注意Linux没有atoi,ltoi,itoa这样的函数，那几个函数是VC独家提供的，不是ANSI C标准，所以*nix要用

到sprintf函数来打印整数的内容到字符串里面。IEEE浮点数对于32位的float来说，从高位到低位分别是1bit符号位，8bit指数位，23bit浮点数位。

当然由于内存地址是从低到高排列的，所以要把这4个字节的内容反过来，作为整数，转换为字符串打印出来的内容才是正确的。在x86机器上，同样

是低位字节在前高位字节在>后，这样做得好处就是可以把浮点数作为有符号整数来排序。
    例如浮点书-0.875，符号为1(复数)，二进制表示为-0.111，表示为1-2之间的小鼠就是-1.11 x 2^-1，指数项-1，加上128得到1111111(127)，因

为指数项的8个bit必须保证是无符号数，所以有了这样的表示。而23bit的整数项则是11000000000000000000，也就是取了-1.11在小数点后面的内容

，没有的后端补0。
所以，-0.875f的2进制表示就是10111111011000000000000000000000。写一个小程序来验证
#include<stdio.h>
#include<stdlib.h>
void pfloat(float f){
  int i,j;
  char buf[4][9];
  char* p=(char*)&f;
  printf("before loop\n");
  for(i=0;i<4;++i){
   for(j=0;j<8;++j){
    buf[i][j]=(p[i]&(0x80>>j))>0?'1':'0';
   }
   buf[i][8]='\0';
  }
  for(i=3;i>=0;i--){
   printf("%s",buf[i]);
  }
  printf("\n");
  printf("end loop\n");
}
int main(void){
  float d1=-0.875;
  pfloat(d1);
  return 0;
}
    看看输出和我们预期的一致。［转载请标明本文CU blog地址］
    浮点数的计算总是充满了陷阱。首先，因为浮点数的精度有限，所以在做四则运算的时候，低位很可能在过程中被舍弃。因此，浮点运算不存在

严格的运>算的结合律。在32位系统上面，浮点数float为4字节长，其中整数位23位，表示范围转换为10位数的话有9个有效数字。所以
  float f1=3.14;
  float f2=1e20;
  float f3=-1e20;
  printf("%d,%f\n",i,f);
  printf("%f\n",f1+f2+f3);
  printf("%f\n",f2+f3+f1);

    上面两个printf的结果是不一样的，第一个结果是0，第二个结果是3.14。再举一个例子
  float k=1.3456789;
  float k2=k;
  k-=1000000.0;
  printf("%f\n",k);
  k+=1000000.0;
  printf("%f\n",k);
  int b=(k==k2);
  printf("%d\n",b);
    结果是什么呢? b=0，因为k的值在之前的运算中，小数点后面已经有5为被舍入了，所以k不再等于k2。要使得k==k2成立，必须提高京都，使用

double--52位整数域，相当于10进制有效数字16位，可以克服上面这个运算的不精确性。
  double d1,d2;
  printf("%f\n",d1);
  d1=d2=1.3456789;
  d2+=1000000.0;
  printf("%f\n",d2);
  d2-=1000000.0;
  printf("%f\n",d2);
现在d==d2的返回值就是真了。为了使得运算结果有可以比较的意义，通常定义一个门限值。#define fequals(a,b) fabs(a-b)<0.01f
如果浮点数计算溢出，printf能够输出适当的表示
  float nan=3.0f/0.0f;
  printf("%f\n",nan);
打印inf，如果结果是负无穷大，打印-inf。


文章出处：DIY部落(http://www.diybl.com/course/3_program/c++/cppxl/20090508/166838.html)


=======================================================
C 中对浮点数的格式化显示
在许多应用程式领域中，都需要控制小数点后的小数位，但是浮点数对此不能提供直接的支持。怎样对程式中的浮点数据进行"整齐"地格式化呢？在

此我们有一个迂回的方法，先把他们转换为字符串，格式化后以文本形式显示出来。

　　在日常编程中--包括对话框、关系数据库、金融程式、SMS程式及一切处理数据文档的程式，需要控制小数点后的小数位的情况很普遍，本文中将

要讲解如何用简单的方法来控制小数位，另外，还要揭开字符串及数据精度的一点点小秘密。

　　问题的引出

　　如有一个函数，其可接受一个long double参数，并将参数转换为字符串，结果字符串应保留两位小数，例如，浮点值123.45678应该生

成"123.45"这样的字符串。表面上看来这是个意义不大的编程问题，然而，假如真要在实际中派上用场，函数应设计为具备一定弹性，以允许调用者

指定小数位数。另外，函数也应该能够处理各种异常情况，如像123.0或123这样的整数。
在开始之前，先看一下编写"优雅"C 代码时的两句"真言"：

　　"真言"1：无论何时需要格式化一个数值，都应先转换为一个字符串。这样可确保每位数刚好占据一个字符。

　　"真言"2：在需要转换为字符串时，请使用<sstream>库。 .

　　转换函数的接口很简洁：第一个参数是需被格式化的数值；第二个参数代表小数点后显示的小数位，且应该具备一个默认值；返回值为一个

string类型：

string do_fraction(long double value, int decplaces=3);

　　注意，第二个参数代表的小数位数中包括了小数点，因此，两位小数需要默认值为3。

　　精度问题

　　当然，第一步是把long double值转换为一个string，使用标准C 库<sstream>简直是手到擒来。然而，有一件事情必须引起注意，因为某些原因

，stringstream对象默认精度为6，而许多程式员错误地把"精度"理解为小数的位数，这是不正确的，精度应指代全部位数。因而，数字1234.56可安

全地通过默认精度6来表示，但12345.67会被截断为12345.6。这样的话，假如您有一个很大的数，如1234567.8，他的结果会静悄悄地转换为科学记数

法：1.23457e 06，这显然不是我们想要的。为避免这样的麻烦，在开始转换之前，应把默认精度设为最大。
为得到long double能表示的最大位数，可使用<limits>库：

string do_fraction(long double value, int decplaces=3) !
{
int prec=numeric_limits<long double>::digits10; // 18
ostringstream out;
out.precision(prec);//覆盖默认精度
out<<value;
string str= out.str(); //从流中取出字符串 数值现在存储在str中，等待格式化。
小数点的位置

　　要进行格式化，首先要确定小数点的位置，假如小数位多于decplaces，do_fraction()会删除多余的。

　　要定位小数位，可使用string::find()，在STL算法中使用了一个常量来代表"数值未找到"，在字符串中，这个常量为string::npos：

char DECIMAL_POINT='.'; // 欧洲用法为','

size_t n=str.find(DECIMAL_POINT);
if ((n!=string::npos)//是否有小数点呢？
{
//检查小数的位数
}

　　假如没有小数点，函数直接返回字符串，否则，函数将继续检查小数位是否多于decplaces。假如是，小数部分将会被截断：

size_t n=str.find(DECIMAL_POINT); 根据专家观察，这样的理论和现象都是值得各位站长深思的，所以希望大家多做研究学习，争取总结出更多更

好的经验!
if ((n!=string::npos)//有小数点吗？
&&(str.size()> n decplaces)) //后面至少更有decplaces位吗？

//在小数decplaces位之后写入nul
str[n decplaces]='\0'; 

　　最后一行覆盖了多余的小数位，他使用了\0常量来截断字符串，要注意，string对象的数据能够包含nul字符；而字符串的实际长度由size()的返

回值决定。因此，您不能假定字符串已被正确地格式化，换句话来说，假如在str中原来为"123.4567"，在插入\0常量之后，他变成了"123.45\07"，

为把str缩减为"123.45"，一般可使用自交换的方法： str.swap(string(str.c_str()) );//删除nul之后的多余字符

　　那他的原理是什么呢？函数string::c_str()返回一个const char *代表此字符串对象，而这个值被用作一个临时string对象的初始化值，接着，

临时对象又被用作str.swap()的参数，swap()会把值"123.45"赋给str。一些老一点的编译器不支持默认模板参数，可能不会让swap()通过编译，假如

是这样的话，使用手工交换来代替：

string temp=str.c_str();
str=temp;
。
　　代码虽不是很"优美"，但能达到目的就行。以下是do_fraction()的完整代码：

string do_fraction(long double value, int decplaces=3)
{
　ostringstream out;
　int prec=
　numeric_limits<long double>::digits10; // 18

　out.precision(prec);//覆盖默认精度
　out<<value;
　string str= out.str(); //从流中取出字符串
　size_t n=str.find(DECIMAL_POINT);
　if ((n!=string::npos) //有小数点吗？
　&& (str.size()> n decplaces)) //后面至少更有decplaces位吗？
　{
　　str[n decplaces]='\0';//覆盖第一个多余的数
　}

　str.swap(string(str.c_str()));//删除nul之后的多余字符

　return str;
}


　　假如不想通过传值返回一个string对象，还可增加一个参数，把str对象以引用传递：

void do_fraction(long double value, string & str, int decplaces=3);

　　从个人的角度来讲，还是倾向于让编译器做这样的优化，另外，使用传值返回，还能够让您以下面这种方式使用do_fraction()：

cout << funct(123456789.69999001) << '\t' << funct(12.011)<<endl;

　　输出：

　　123456789.69 12.01


==================================================================
由于编译器的优化，可能会出现两个逻辑上相等的变量比较结果不同的情况，例如：
a = f(10);// f内部进行浮点运算，返回浮点结果至a，中间发生了精度截断（因为CPU浮点寄存器为80位，而a为64位
b = f(10);　　
e = a == b;// 这里，编译器优化后的代码直接用CPU寄存器中的结果（b'）与变量a作比较，由于b'没有被截断，所以e == 0
一般来说，比较两个浮点数时只能用一个范围来衡量它们的差值，若不超过这个范围，则认为相等。那么，这个范围如何取值？取double或float能够

表示的最小的正数是最合理的吗？
#
看你拿浮点数作什么用了。例如在银行里用得比较多的是金额，以元为单位，一般比较两个金额是否相等是这样做的：

double a, b;

if( abs(a-b) < 0.0005 )
    相等；
else
    不相等；

但如果是用作工程上的运算，这样的精度肯定就不行了！
#

============================================
C浮点数表示方法



用4字节存储一个浮点数，格式遵循IEEE-754标准(详见c51.pdf第179页说明)。一
个浮点数用两个部分表示，尾数和2的幂，尾数代表浮点上的实际二进制数，2的幂代表指
数，指数的保存形式是一个0到255的8位值，指数的实际值是保存值(0到255)减去127,一个
范围在-127到+128之间的值，尾数是一个24位值(代表大约7个十进制数)，最高位MSB通常是
1，因此不保存。一个符号位表示浮点数是正或负。
浮点数保存的字节格式如下：
地址        +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。 



=================================================

发表于 @ 2009年


本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/wubati/archive/2009/08/01/4396520.aspx