爲什麼0.1+0.2=0.30000000000000004

浮點數運算

你使用的語言並不爛，它能夠做浮點數運算。計算機天生只能存儲整數，因此它需要某種方法來表示小數。這種表示方式會帶來某種程度的誤差。這就是爲什麼往往 0.1 + 0.2 不等於 0.3。

爲什麼會這樣？

實際上很簡單。對於十進制數值系統（就是我們現實中使用的），它只能表示以進制數的質因子爲分母的分數。10 的質因子有 2 和 5。因此 1/2、1/4、1/5、1/8和 1/10 都可以精確表示，因爲這些分母只使用了10的質因子。相反，1/3、1/6 和 1/7 都是循環小數，因爲它們的分母使用了質因子 3 或者 7。二進制下（進制數爲2），只有一個質因子，即2。因此你只能精確表示分母質因子是2的分數。二進制中，1/2、1/4 和 1/8 都可以被精確表示。但是，1/5 或者 1/10 就變成了循環小數。所以，在十進制中能夠精確表示的 0.1 與 0.2（1/10 與 1/5），到了計算機所使用的二進制數值系統中，就變成了循環小數。當你對這些循環小數進行數學運算時，並將二進制數據轉換成人類可讀的十進制數據時，會對小數尾部進行截斷處理。

下面是在不同的語言中，運行 0 .1 + 0.2 的輸出結果：

 

語言	代碼	結果
C	#include<stdio.h>int  main(int argc, char* argv) {printf(“%.17fn”, .1+.2);return 0;}	0.30000000000000004
C++	#include  <iomanip>std::cout << setprecision(17) << 0.1 + 0.2  << std.endl;	0.30000000000000004
PHP	echo .1 + .2;	0.3
注1：PHP 將  0.30000000000000004 格式化成字符串時，會把它縮短成 “0.3″。爲了得到需要的浮點數結果，在 ini文件中調整精度設置：iniset(“precision”,  17)。
MySQL	SELECT .1 +  .2;	0.3
Postgres	SELECT select  0.1::float + 0.2::float;	0.3
Delphi XE5	writeln(0.1 +  0.2);	3.00000000000000E-0001
Erlang	io:format(“~w~n”,  [0.1 + 0.2]).	0.30000000000000004
Elixir	IO.puts(0.1 +  0.2)	0.30000000000000004
Ruby	puts 0.1 + 0.2  And puts 1/10r +  2/10r	0.30000000000000004  And 3/10
注2：Ruby 2.1及以後版本在語法上支持有理數。對於老版本，請使用 Rational。Ruby還有一個專門處理小數的庫： BigDecimal。
Python 2	print(.1 + .2) float(decimal.Decimal(“.1″)  + decimal.Decimal(“.2″))  .1 + .2	0.3 0.3 0.30000000000000004
注3：Python 2 中的 “print” 語句將 0.30000000000000004 轉成一個字符串，並縮短成 “0.3″。爲了達到需要的浮點數結果，使用 print(repr(.1 + .2))。在 Python 3中這是內置設定（見下面例子）。
Python 3	print(.1 + .2) .1 + .2	0.30000000000000004 0.30000000000000004
Lua	print(.1 + .2)  print(string.format(“%0.17f”, 0.1 + 0.2))	0.3  0.30000000000000004
JavaScript	document.writeln(.1  + .2);	0.30000000000000004
Java	System.out.println(.1  + .2);System.out.println(.1F + .2F);	0.30000000000000004 0.3
Julia	.1 + .2	0.30000000000000004
注4：Julia 內置 支持有理數 ，並且還有一個內置的數據類型BigFloat，它支持任意精度。要得到正確的運算結果，使用 1//10 + 2//10 會返回3//10。
Clojure	(+ 0.1 0.2)	0.30000000000000004
注5：Clojure 支持任意精度的數據。 (+ 0.1M 0.2M) 返回 0.3M，而 (+ 1/10 2/10) 返回 3/10。
C#	Console.WriteLine(“{0:R}”,  .1 + .2);	0.30000000000000004
GHC (Haskell)	0.1 + 0.2	0.30000000000000004
注6：Haskell 支持有理數。要得到正確的運算結果，使用 (1 % 10) + (2 %  10) 返回 3 % 10。
Hugs (Haskell)	0.1 + 0.2	0.3
bc	0.1 + 0.2	0.3
Nim	echo(0.1 +  0.2)	0.3
Gforth	0.1e 0.2e f+  f.	0.3
dc	0.1 0.2 + p	.3
Racket (PLT  Scheme)	(+ .1 .2) And  (+ 1/10 2/10)	0.30000000000000004  And 3/10
Rust	extern crate  num; use num::rational::Ratio; fn main() { println!(.1+.2); println!(“1/10 +  2/10 = {}”, Ratio::new(1, 10) + Ratio::new(2, 10)); }	0.30000000000000004  3/10
注7：Rust 中，使用 num  crate 支持獲得 有理數支持 。
Emacs Lisp	(+ .1 .2)	0.30000000000000004
Turbo Pascal  7.0	writeln(0.1 +  0.2);	3.0000000000E-01
Common Lisp	(+ .1 .2) And  * (+ 1/10 2/10)	0.3 And 3/10
Go	package main  import “fmt” func main() { fmt.Println(.1 + .2) var a float64 = .1 var b  float64 = .2 fmt.Println(a + b) fmt.Printf(“%.54fn”, .1 + .2) }	0.3  0.30000000000000004 0.299999999999999988897769753748434595763683319091796875
注8：Go語言的數字常數有任意精度。
Objective-C	0.1 + 0.2;	0.300000012
OCaml	0.1 +. 0.2;;	float =  0.300000000000000044
Powershell	PS C:>0.1 +  0.2	0.3
Prolog  (SWI-Prolog)	?- X is 0.1 +  0.2.	X =  0.30000000000000004.
Perl 5	perl -E ‘say  0.1+0.2′ perl -e ‘printf q{%.17f}, 0.1+0.2′	0.3  0.30000000000000004
Perl 6	perl6 -e ‘say  0.1+0.2′ perl6 -e ‘say sprintf(q{%.17f}, 0.1+0.2)’ perl6 -e ‘say 1/10+2/10′	0.3 0.30000000000000000  0.3
注9：Perl 6 與 Perl 5 不同，默認使用有理數。因此 .1 被存儲成類似這樣 { 分子 => 1, 分母 => 10 }.
R	print(.1+.2)  print(.1+.2, digits=18)	0.3  0.300000000000000044
scala	scala -e  ‘println(0.1 + 0.2)’ And scala -e ‘println(0.1F + 0.2F)’ And scala -e  ‘println(BigDecimal(“0.1″) + BigDecimal(“0.2″))’	0.30000000000000004  And 0.3 And 0.3
Smalltalk	0.1 + 0.2.	0.30000000000000004
Swift	0.1 + 0.2	0.3
D	import  std.stdio; void main(string[] args) { writefln(“%.17f”, .1+.2);  writefln(“%.17f”, .1f+.2f); writefln(“%.17f”, .1L+.2L); }	0.29999999999999999  0.30000001192092896 0.30000000000000000