Comment puis-je imprimer une valeur double avec une précision maximale en utilisant la méthode cout?

Utilisation std::setprecision :

std::cout << std::setprecision (15) << 3.14159265358979 << std::endl;

voici ce que j'utiliserais:

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

fondamentalement le paquet limits a des traits pour tous les types de construction.

L'un des traits pour les nombres à virgule flottante (float/double/long double) est l'attribut digits10. Cela définit la précision (j'oublie la terminologie exacte) d'un nombre de virgule flottante en base 10.

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

Pour plus de détails sur les autres attributs.

la voie iostream est un peu bouchée. Je préfère utiliser boost::lexical_cast parce qu'il calcule la bonne précision pour moi. Et c'est rapide , aussi.

#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;

sortie:

Pi: 3.14159265358979

Voici comment afficher un double avec pleine précision:

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

Cette affiche:

100.0000000000005

max_digits10 est le nombre de chiffres qui sont nécessaires pour représenter de façon unique toutes différentes valeurs doubles. max_digits10 représente le nombre de chiffres avant et après la virgule.

N'utilisez pas set_precision(max_digits10) avec std::fixe.

Sur la notation Fixe, set_precision () fixe le nombre de chiffres seulement après le point décimal. C'est incorrect car max_digits10 représente le nombre de chiffres avant et après le point décimal.

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

cela affiche un résultat incorrect:

100.00000000000049738

par pleine précision, je suppose que moyenne assez de précision pour montrer la meilleure approximation à la valeur prévue, mais il faut souligner que double est stocké en utilisant la représentation de base 2 et la base 2 ne peut pas représenter quelque chose d'aussi insignifiant que 1.1 exactement. La seule façon d'obtenir la précision full-full du double réel (sans erreur de arrondi) est d'imprimer les bits binaires (ou HEX nybbles). Une façon de le faire est d'écrire le double à un union et ensuite l'impression de la valeur entière des bits.

union {
    double d;
    uint64_t u64;
} x;
x.d = 1.1;
std::cout << std::hex << x.u64;

cela vous donnera la précision de 100% du double... et être tout à fait illisible parce que les humains ne peuvent pas lire le double format IEEE ! Wikipedia a une bonne écriture sur la façon d'interpréter les bits binaires.

dans le nouveau c++, vous pouvez faire

std::cout << std::hexfloat << 1.1;

printf("%.12f", M_PI);

%.12f signifie point flottant, avec une précision de 12 chiffres.

cout est un objet qui a un tas de méthodes que vous pouvez appeler pour changer la précision et le formatage des documents imprimés.

Il y a un setprecision(... en fonctionnement, mais vous pouvez également définir d'autres choses comme la largeur d'impression, etc.

cherchez la référence de votre IDE.

très probablement...

#include <limits>

using std::numeric_limits;

    ...
    cout.precision(numeric_limits<double>::digits10 + 1);
    cout << d;

Avec ostream::précision(int)

cout.precision( numeric_limits<double>::digits10 + 1);
cout << M_PI << ", " << M_E << endl;

donnera

3.141592653589793, 2.718281828459045

Pourquoi vous devez dire "+1", je n'ai aucune idée, mais le chiffre supplémentaire pour vous est correct.

comment imprimer une valeur double avec une pleine précision en utilisant cout?

utiliser hexfloat ou

utilisez scientific et réglez la précision

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

un trop grand nombre de réponses ne concernent qu'une seule des questions suivantes: 1) Base 2) disposition fixe/scientifique ou 3) Précision. Trop de réponses avec précision ne fournissent pas la valeur nécessaire. D'où cette réponse à une vieille question.

1. quelle base?

a double est certainement encodé en utilisant la base 2. Une approche directe avec C++11 est d'imprimer en utilisant std::hexfloat .

Si une sortie non décimale est acceptable, nous sommes faits.

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. sinon: fixed ou scientific ?

Un double est un à virgule flottante "1519680920 type", pas point fixe .

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 

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

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

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

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