为什么0.1+0.2=0.30000000000000004

语言

代码

结果

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