float、double判斷是否等于0

如果是兩個int類型的數據，想要判斷他們是否相等，我們可以直接比較。

int a =11;
int b=11;
if(a==b)

答案是肯定的，BUT如果是float和double：

float是32位，double是64位。float32位中，有1位符號位，8位指數位，23位尾數位。double64位中，1位符號位，11位指數位，52位尾數位。

一般float型只能精確到小數到后六位即1e-6,將float型的數a的絕對值abs（a）與1e-6比較，如果abs（a）比1e-6還要小的話就可以認為a的值為零，因為小數六位以后是不精確的，是沒有意義的。

比如數0.0000001雖然確實不等于零，但是第七位小數1是沒有意義的就可以認為這個數等于0。

float，double分別遵循R32-24,R64-53的標準。所以float的精度誤差在1e-6；double精度誤差在1e-15，所以要判斷一個單精度浮點數：則是if( abs(f) <= 1e-6)；要判斷一個雙精度浮點數：則是if( abs(f) <= 1e-15 )；若小于，為0，大于，不為0 。

代碼如下：

#include <stdio.h>
#include <stdlib.h>
#include <math.h> ?//必須加這個頭文件
int main()
{
?? ?float a = 0;
?? ?if(fabs(a) < 1e-6)?
?? ?{
?? ??? ?printf("%f\n",fabs(a));
?? ??? ?printf("float Equal 0!\n");
?? ?}
?? ?else
?? ?{
?? ??? ?printf("%f\n",fabs(a));
?? ??? ?printf("float not Equal 0!\n");
?? ?}
?? ?
?? ?double b = 0;?
?? ?if(fabs(b) < 1e-15)
?? ?{
?? ??? ?printf("%f\n",fabs(a));
?? ??? ?printf("double Equal 0!\n");
?? ?}
?? ?else
?? ?{
?? ??? ?printf("%f\n",fabs(a));
?? ??? ?printf("double not Equal 0!\n");
?? ?}
?? ?
?? ?return 0;
}

返回的都是相等！

float和double的比較

在c++開發中，double或者float類型判斷相等性不能簡單的用等于符號==進行，一般會采用如下方式進行判斷

static inline bool DoubleEqual(double a, double b)
{
? ? ?return fabs(a - b) < std::numeric_limits<double>::epsilon();
}

為了驗證這個說法，我在機器上寫了如下一段代碼， 結果竟然沒有一次輸出，貌似可以直接比較

double a = 0, b = 0;
for(int i = 0; i < 100000; i++) {
? ? a += i * 0.1;
? ? b += i * 0.1;
? ? if ( a != b) {
? ? ? ? printf("%f %f\n", a ,b);
? ? }
}

那么到底浮點數能不能比較？

#include<stdio.h>
int main()
{
? ? float x = 0.1;
? ? if (x == 0.1)
? ? ? ? printf("1");
? ? else if (x == 0.1f)
? ? ? ? printf("2");
? ? else
? ? ? ? printf("3");
}

這段代碼輸出2，這也就意味著 x == 0.1 返回了false。 x==0.1f 返回了true。

這又是為什么呢？先看一段代碼

#include<stdio.h>
int main()
{
? ? float x = 0.1;
? ? printf("%d %d %d", sizeof(x), sizeof(0.1), sizeof(0.1f));
? ? return 0;
}

這段代碼輸出 4 8 4, 這也就說明代碼中不加上f后綴，默認會采用double類型（sizeof(0.1)中的0.1作為常量默認是按照double存儲的）。

前面的例子中 x == 0.1 導致了x 變量提升到double（因為右邊的0.1是double類型，所以x要提升到double），double 位數比float要多，這時候就需要二進制補全（x進行了補全，只是把后面缺的近30位補成了0，而不是把x這個0.1重新按照double進行組織，也就是補全后的x雖然小數部分達到了52位，但是后面的29位都是0）。

0.1的二進制（double）表示為(0.00011001100110011…) 后面的...表示循環數。

由于float的位數（23）要小于double（52）的位數，在x變量提升到double后， 編譯器會將多余的尾補全尾0。

0.00011001100110011001100 float 0.1

在和0.1比較時（0.1默認為double）時，x會被編譯器進行變量提升，變成 0.00011001100110011001100000000000000000 (float 0.1 提升到double 0.1的二進制表示)

而double類型的0.1的表示為：

0.0001100110011001100110011001100110011001100110011001(原double 0.1的二進制表示)

上述結果就得到了解釋，float提升到double后的二進制表示和double 0.1的二進制完全不一樣。

難道所有的比較都會有這個問題嗎？并不是。下面有個例子就不會產生問題比如

#include<stdio.h>
int main()
{
? ? float x = 0.5;
? ? if (x == 0.5)
? ? ? ? printf("1");
? ? else if (x == 0.5f)
? ? ? ? printf("2");
? ? else
? ? ? ? printf("3");
}

這個就輸出了1,?

0.5的二進制表示為0.100000…， 由此看見就算編譯器在尾補上補充再多的0，也不會導致二進制表示不一樣。

總結：同類型的比較不設計到變量提升或者截斷，可以直接比較。當變量提升或者截斷后，二進制沒有循環模式的也是可以直接比較的。?