The precision of C language printf output floating point numbers

Believe to learn C People who speak English are right printf This function is very familiar , But many people may not be clear about some problems . Recently 《 numerical analysis 》, This makes me have a new understanding of numerical accuracy , Or that sentence, mathematics is the most straightforward weapon , There is no mathematical basis but to stay on the surface , It's hard to know why ！

Let's look at the following cases ：

float f = 0.3;
printf("%f",f);

Yes, you can output ：0.300000
This is a C The default output of the language 6 position ,%f The output of makes you feel completely OK , wait , It doesn't seem right , It doesn't mean that computers can't accurately represent floating-point numbers ？ How can this be expressed exactly ？ wait a moment , Look at the following code snippet .

float f = 0.3;
printf("%.8f",f);

The output here is ：0.30000001
Finally showed his feet , Sure enough, it's still not accurate , But why is this result ？ So let's look down

double f = 0.3;
printf("%.8lf",f);

The output here is ：0.30000000
That's strange , Here is the float Instead of double Why is it right ？ Output more bits ？

double f = 0.3;
printf("%.18lf",f);

The output here is ：0.299999999999999990
Now it's back to the imprecise value , Why is that ？

Let's talk about this problem ：

We might as well put 0.3 Convert to binary to see what it looks like , Recommend a website that can realize multiple hexadecimal conversions ：http://www.sojson.com/hexconvert.html

0.3 The binary result of is ：0.0100110011001100110011001100110011001100110011001101
Of course, there are many more , To be exact, it should be an infinite decimal . according to IEEE754 standard , For single precision floating point numbers , The mantissa is 23 position , So intercept 23 Bit binary , Of course, the first one from left to right is not 0 The numbers start ,

therefore 0.3 Of float The mantissa of is ：0.010011001100110011001101

Notice that the last one here is 1, instead of 0, In the original binary string is 0, The principle of rounding is adopted here , recall , stay 10 For example 0.57 The result of rounding to one decimal place is 0.6, That's because No 2 The decimal is 7, More than the 5 So in 1 position , In binary, the next bit is 1 still 0, If it is 1 Carry on . The... In the original binary string 24 Position as 1, So carry to 23 position , therefore 23 A into 1.

So let's move on 0.3 Of float The mantissa of is 0.010011001100110011001101 Convert to 10 Let's see .

The result is ：0.300000011920928955078125

That's why

printf("%f",f);     // You can get  0.300000
printf("%.8f",f);   // You can get  0.30000001

You can output more digits ：

printf("%.15f",f);  // You can get  0.300000011920929

You can actually see that , Here the output is also rounded off 0.300000011920928955078125 Retain 15 One decimal place to get 0.300000011920929

As for the 4 Why is the result of double precision output less than 0.3, That's because its mantissa has 52 position , So when intercepting binary bits , because 53 Is it 0, therefore 52 The digits remain unchanged , Actually, it is smaller than the original number , because 53 There are still a lot of digits after bits 1 There is .

Then there is another question , Why?

double f = 0.3;
printf("%.8lf",f);

The output is ：0.30000000
instead of ：0.29999999

This is because C Language in output processing , Rounding is used again . That's why we use %f Output 0.3 Can see 0.30000 Why .