Precision has to be the main concern when performing floating point operations in C++, especially for scientific computations, financial calculations, and data analysis. By default, the cout stream does not show you the full precision of that double value. In this article, we will discuss how to print a double with full precision using cout and other effective methods.
Table of Contents:
Understanding the Precision of double in C++
A double is a 64-bit floating-point data type, so it has a precision of about 15 to 17 significant decimal digits in C++. When cout is used in its default state (i.e., without any formatting), it prints only about six significant decimal digits. This is so because of a default setting for precision exhibited in the output of the cout that is very often, and not enough for scientific or heavy precision calculations.
Example:
Output:
The program displays a double value through cout without any formatting. If cout is not specified in this particular setting or any formatting, it rounds off the output to six decimal places.
Methods to Print a Double with Full Precision in C++
Below are the methods that you can use to print a double with full precision in C++:
Method 1: Using std::setprecision
With C++, you can control the number of digits printed or displayed when printing floating-point numbers with std::setprecision from the <iomanip> library. By default, only about six significant decimal digits are printed by cout unless std::setprecision is used to change this.
Example:
Output:
The code shows that the full precision of up to 17 significant digits is assured in the C++ program by applying std::setprecision(17) before printing out the double value.
Method 2: Using std::fixed
The std::fixed manipulator forces the floating-point numbers to be displayed in fixed-point notation rather than scientific notation. When combined with std::setprecision, it controls the number of decimal places instead of the total significant digits.
Example:
Output:
The code shows the use of std::fixed combined with std::setprecision(15) to make sure that the double value is displayed in exactly 15 decimal points.
Method 3: Using std::scientific
The std::scientific manipulator forces floating-point numbers to be displayed in scientific notation (exponential form). When used together with std::setprecision, it controls the number of decimal places in the scientific notation format.
Example:
Output:
The code shows how to set the precision as high as 15 decimal places in scientific notation with the use of std::scientific and std::setprecision(15).
Method 4: Using cout.precision()
Rather than using std::setprecision, you can directly call this member function precision() of cout to set the number of significant digits that should be printed.
Example:
Output:
The program sets the precision with cout.precision(17), thus allowing the double value to always print out 17 significant digits.
Method 5: Using std::hexfloat
The std::hexfloat manipulator allows you to print floating-point numbers in hexadecimal floating-point notation, which is useful for low-level debugging, binary representation analysis, and certain scientific applications.
Example:
Output:
The program uses std::hexfloat to show the double value in hexadecimal floating-point notation, which can be useful during low-level debugging and binary representation analysis.
Method 6: Using boost::lexical_cast
Boost library is another better method of casting double to the same string while maintaining the full precision of digits. It is a straightforward and user-friendly way compared to std::to_string() since it allows more control over the precision.
Example:
Output:
The program uses boost::lexical_cast to convert double to std::string while keeping the full precision.
From C++20, the std::format function of the <format> standard header provides a modern and flexible way of formatting floating-point numbers. This is way more powerful and easier to use than traditional cout manipulators.
Example:
Output:
The code shows how the std::format (C++20) is used to print the double value with 17 decimal places. It can be used with a C++20-compatible compiler.
Method 8: Using std::numeric_limits
You can use std::numeric_limits::digits10 from this <limits> header and set the output to preserve the absolute precision of the double-precision floating-point number.
Example:
Output:
The code shows how to ensure full precision by setting std::setprecision(std::numeric_limits<double>::digits10 + 1), preserving all significant decimal digits in fixed-point notation.
Comparison of Methods to Print Double Value
| Method | Precision Control and Type | Output Format | Usage |
| std::setprecision(n) | High, Total significant digits | Default (fixed or scientific) | General precision control |
| std::fixed | High, Decimal places | Fixed-point notation | Financial and formatted output |
| std::scientific | High, Decimal places | Scientific notation | Large/small numbers |
| cout.precision(n) | High, Total significant digits | Default (fixed or scientific) | Similar to std::setprecision |
| std::hexfloat | Moderate, Binary representation | Hexadecimal floating-point | Low-level debugging |
| boost::lexical_cast | High, Full precision | String conversion | Storing/converting to text |
| std::format (C++20) | High, Customizable | Flexible (fixed, scientific, etc.) | Modern & flexible formatting |
Conclusion
You can print a double with full precision using std::setprecision, std::fixed, or std::scientific for a standard format. More modern alternatives like std::format (C++20) and boost::lexical_cast offer greater flexibility. The choice of one or the other depends on your exact output needs, whether decimal, scientific, or hexadecimal representation.
How to Print a Double Value with Full Precision using cout – FAQs
1. Why does cout truncate my double value?
The default cout only prints 6 digits of floating-point precision. To display more digits, you will need to set an appropriate precision using std::setprecision(n).
2. How many digits of precision can a double hold?
Usually, a double in C++ can hold 15 to about 17 significant figures on mainstream platforms, depending on the system and compiler options used.
3. What is std::fixed, and how does it relate to std::setprecision?
The std::fixed method sets a fixed amount of decimal places in a printed number, while the std::setprecision(n) ensures that printed decimal counts are always added to ensure n total significant figures unless std::fixed is being used.
4. Why do floating-point rounding errors occur?
Floating-point numbers are stored in binary form, and since not all decimal numbers have an equivalent binary representation, rounding errors occur.
5. Does std::format work well for all C++ versions?
No, std::format was introduced in C++20. In case your compiler does not support it, you can either use std::ostringstream or the less likely boost::lexical_cast instead.