Wie drucke ich mit cout einen doppelten Wert mit voller Genauigkeit?

In meiner früheren Frage habe ich a gedruckt double verwenden cout das wurde abgerundet, als ich es nicht erwartet hatte. Wie kann ich machen cout drucke a double mit voller Präzision?

Sie können die Genauigkeit direkt einstellen std::cout und benutze die std::fixed Formatbezeichner.

double d = 3.14159265358979;
cout.precision(17);
cout << "Pi: " << fixed << d << endl;

Du kannst #include <limits> um die maximale Präzision eines Floats oder Doubles zu erhalten.

#include <limits>

typedef std::numeric_limits< double > dbl;

double d = 3.14159265358979;
cout.precision(dbl::max_digits10);
cout << "Pi: " << d << endl;

Verwenden std::setprecision:

#include <iomanip>
std::cout << std::setprecision (15) << 3.14159265358979 << std::endl;

Hier ist, was ich verwenden würde:

std::cout << std::setprecision (std::numeric_limits<double>::digits10 + 1)
          << 3.14159265358979
          << std::endl;

Grundsätzlich hat das Limits-Paket Eigenschaften für alle eingebauten Typen.
Eines der Merkmale für Fließkommazahlen (Float/Double/Long Double) ist das Attribut digits10. Dies definiert die Genauigkeit (ich vergesse die genaue Terminologie) einer Gleitkommazahl in Basis 10.

Sehen: http://www.cplusplus.com/reference/std/limits/numeric_limits.html

Einzelheiten zu anderen Attributen.

In C++20 können Sie verwenden std::format um dies zu tun:

std::cout << std::format("{}", M_PI);

Ausgang (unter der Annahme von IEEE754 double):

3.141592653589793

Das Standard-Gleitkommaformat ist die kürzeste Dezimaldarstellung mit Roundtrip-Garantie. Der Vorteil dieser Methode gegenüber der setprecision E/A-Manipulator ist, dass er keine unnötigen Ziffern druckt.

In der Zwischenzeit können Sie verwenden die {fmt}-Bibliothek, std::format basiert auf. {fmt} bietet auch die print Funktion, die dies noch einfacher und effizienter macht (Gottriegel):

fmt::print("{}", M_PI);

Haftungsausschluss: Ich bin der Autor von {fmt} und C++20 std::format.

Der iostreams-Weg ist etwas klobig. Ich benutze lieber boost::lexical_cast weil es für mich die richtige Genauigkeit berechnet. Und Es ist schnellzu.

#include <string>
#include <boost/lexical_cast.hpp>

using boost::lexical_cast;
using std::string;

double d = 3.14159265358979;
cout << "Pi: " << lexical_cast<string>(d) << endl;

Ausgabe:

Pi: 3,14159265358979

Wie drucke ich a double Wert mit voller Genauigkeit mit cout?

Verwenden hexfloat oder
verwenden scientific und stellen Sie die Genauigkeit ein

std::cout.precision(std::numeric_limits<double>::max_digits10 - 1);
std::cout << std::scientific <<  1.0/7.0 << '\n';

// C++11 Typical output
1.4285714285714285e-01

Zu viele Antworten sprechen nur eine von 1) Basis 2) festem/wissenschaftlichem Layout oder 3) Präzision an. Zu viele Antworten mit Präzision geben Sie nicht den richtigen Wert an, der benötigt wird. Daher diese Antwort auf eine alte Frage.

1. Welche Basis?

EIN double ist sicherlich mit Basis 2 kodiert. Ein direkter Ansatz mit C++11 ist das Drucken mit std::hexfloat.
Wenn eine nicht dezimale Ausgabe akzeptabel ist, sind wir fertig.

std::cout << "hexfloat: " << std::hexfloat << exp (-100) << '\n';
std::cout << "hexfloat: " << std::hexfloat << exp (+100) << '\n';
// output
hexfloat: 0x1.a8c1f14e2af5dp-145
hexfloat: 0x1.3494a9b171bf5p+144

2. Andernfalls: fixed oder scientific?

EIN double ist ein Fließkomma Typ, nicht Fixpunkt.

Machen nicht verwenden std::fixed da das nicht klein gedruckt werden kann double als alles andere als 0.000...000. Für groß doublees druckt vielleicht viele Ziffern Hunderte von fragwürdiger Aussagekraft.

std::cout << "std::fixed: " << std::fixed << exp (-100) << '\n';
std::cout << "std::fixed: " << std::fixed << exp (+100) << '\n';
// output
std::fixed: 0.000000
std::fixed: 26881171418161356094253400435962903554686976.000000 

Um mit voller Präzision zu drucken, verwenden Sie es zuerst std::scientific die “Gleitkommawerte in wissenschaftlicher Notation schreiben”. Beachten Sie den Standardwert von 6 Stellen nach dem Dezimalkomma, ein unzureichender Betrag wird im nächsten Punkt behandelt.

std::cout << "std::scientific: " << std::scientific << exp (-100) << '\n';  
std::cout << "std::scientific: " << std::scientific << exp (+100) << '\n';
// output
std::scientific: 3.720076e-44
std::scientific: 2.688117e+43

3. Wie viel Genauigkeit (wie viele Stellen insgesamt)?

EIN double codiert mit der binären Basis 2 codiert die gleiche Genauigkeit zwischen verschiedenen Potenzen von 2. Dies sind häufig 53 Bit.

[1.0…2.0) there are 2⁵³ different double,
[2.0…4.0) there are 2⁵³ different double,
[4.0…8.0) there are 2⁵³ different double,
[8.0…10.0) there are 2/8 * 2⁵³ different double.

Yet if code prints in decimal with N significant digits, the number of combinations [1.0…10.0) is 9/10 * 10^N.

Whatever N (precision) is chosen, there will not be a one-to-one mapping between double and decimal text. If a fixed N is chosen, sometimes it will be slightly more or less than truly needed for certain double values. We could error on too few (a) below) or too many (b) below).

3 candidate N:

a) Use an N so when converting from text-double-text we arrive at the same text for all double.

std::cout << dbl::digits10 << '\n';
// Typical output
15

b) Use an N so when converting from double-text-double we arrive at the same double for all double.

// C++11
std::cout << dbl::max_digits10 << '\n';
// Typical output
17

When max_digits10 is not available, note that due to base 2 and base 10 attributes, digits10 + 2 <= max_digits10 <= digits10 + 3, we can use digits10 + 3 to insure enough decimal digits are printed.

c) Use an N that varies with the value.

This can be useful when code wants to display minimal text (N == 1) or the exact value of a double (N == 1000-ish in the case of denorm_min). Yet since this is “work” and not likely OP’s goal, it will be set aside.

It is usually b) that is used to “print a double value with full precision”. Some applications may prefer a) to error on not providing too much information.

With .scientific, .precision() sets the number of digits to print after the decimal point, so 1 + .precision() digits are printed. Code needs max_digits10 total digits so .precision() is called with a max_digits10 - 1.

typedef std::numeric_limits< double > dbl;
std::cout.precision(dbl::max_digits10 - 1);
std::cout << std::scientific <<  exp (-100) << '\n';
std::cout << std::scientific <<  exp (+100) << '\n';
// Typical output
3.7200759760208361e-44
2.6881171418161356e+43
//2345678901234567  17 total digits

Similar C question

Here is how to display a double with full precision:

double d = 100.0000000000005;
int precision = std::numeric_limits<double>::max_digits10;
std::cout << std::setprecision(precision) << d << std::endl;

This displays:

100.0000000000005

max_digits10 is the number of digits that are necessary to uniquely represent all distinct double values. max_digits10 represents the number of digits before and after the decimal point.

Don’t use set_precision(max_digits10) with std::fixed.
On fixed notation, set_precision() sets the number of digits only after the decimal point. This is incorrect as max_digits10 represents the number of digits before and after the decimal point.

double d = 100.0000000000005;
int precision = std::numeric_limits<double>::max_digits10;
std::cout << std::fixed << std::setprecision(precision) << d << std::endl;

This displays incorrect result:

100.00000000000049738

Note: Header files required

#include <iomanip>
#include <limits>