从文本文件C ++读入时奇怪的数字舍入

Question

I have a text line containing only the following lines.

0.01180994648909809 0.0118339243907452 0.01153905217670122

0.0376759911531237 0.03771224865527065 0.03765957194275842

I used the following code to read this data and output it to terminal

using namespace std;

    int main(int argc, char *argv[])
    {

      ifstream infile(argv[1]);
      string line;
      double a,b,c;

      while(getline(infile,line))
      {
        istringstream iss(line);
        iss >> a >> b >> c;
        cout<<a<<"\t"<< b << "\t"<<c<<endl;
       }

  return 0;}

The output I got was

0.0118099   0.0118339   0.0115391
0.037676    0.0377122   0.0376596

Why is it that in the output the numbers have been rounded to 7 digits after the decimal? Is this rounding performed only while displaying to standard output?

Answer 1

EDIT: Moving the proposed solution at top of the relevant information.

You can use set::precision to see the proper precision.

Apart from the answer above, It is important to note that Whenever, You use float and decimal numbers Rounding Errors & Precision are an definite factor.

What is an Precision Error?

The precision of a floating point number is how many digits it can represent without losing any information it contains.

Consider the fraction 1/3 . The decimal representation of this number is 0.33333333333333… with 3′s going out to infinity. An infinite length number would require infinite memory to be depicted with exact precision, but float or double data types typically only have 4 or 8 bytes. Thus Floating point & double numbers can only store a certain number of digits, and the rest are bound to get lost. Thus, there is no definite accurate way of representing float or double numbers with numbers that require more precision than the variables can hold.

What is a Rounding Error?

There is a non-obvious differences between binary and decimal (base 10) numbers.
Consider the fraction 1/10 . In decimal , this can be easily represented as 0.1 , and 0.1 can be thought of as an easily representable number. However, in binary, 0.1 is represented by the infinite sequence: 0.00011001100110011…

An example:

#include <iomanip>
int main()
{
    using namespace std;
    cout << setprecision(17);
    double dValue = 0.1;
    cout << dValue << endl;
}

This output is:

0.10000000000000001

And not

0.1.

This is because the double had to truncate the approximation due to it's limited memory, which results in a number that is not exactly 0.1 . Such an scenario is called a Rounding error .

So be aware of these errors when you use floar or double.