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

J’ai donc eu la réponse à ma dernière question (je ne sais pas pourquoi je n’y ai pas pensé). cout un double utilisant le cout qui a été arrondi quand je ne m’y attendais pas. Comment puis-je faire imprimer un double utilisant une précision totale?

Vous pouvez définir la précision directement sur std::cout et utiliser le spécificateur std::fixed format.

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

Vous pouvez #include pour obtenir la précision maximale d'un float ou d'un double.

 #include  typedef std::numeric_limits< double > dbl; double d = 3.14159265358979; cout.precision(dbl::max_digits10); cout < < "Pi: " << fixed << d << endl; 

Utilisez std::setprecision :

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

Voici ce que j’utiliserais:

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

Fondamentalement, le paquet de limites a des traits pour tous les types de construction.
L'une des caractéristiques des nombres à virgule flottante (float / double / long double) est l'atsortingbut digits10. Ceci définit la précision (j'oublie la terminologie exacte) d'un nombre à virgule flottante dans la base 10.

Voir: http://www.cplusplus.com/reference/std/limits/numeric_limits.html
Pour plus de détails sur les autres atsortingbuts.

La méthode iostreams est plutôt maladroite. Je préfère utiliser boost::lexical_cast car il calcule la bonne précision pour moi. Et c’est rapide aussi.

 #include  #include  using boost::lexical_cast; using std::ssortingng; double d = 3.14159265358979; cout < < "Pi: " << lexical_cast(d) < < endl; 

Sortie:

Pi: 3.14159265358979

Voici comment afficher un double en toute précision:

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

Cela affiche:

100.0000000000005

max_digits10 est le nombre de chiffres nécessaires pour représenter de manière unique toutes les valeurs doubles distinctes. max_digits10 représente le nombre de chiffres avant et après le point décimal.

N'utilisez pas set_precision (max_digits10) avec std :: fixed.
Sur la notation fixe, set_precision () définit le nombre de chiffres uniquement après le point décimal. Ceci 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::max_digits10; std::cout < < std::fixed << std::setprecision(precision) << d << std::endl; 

Cela affiche un résultat incorrect:

100.00000000000049738

En toute précision, je suppose que la précision moyenne est suffisante pour montrer la meilleure approximation de la valeur voulue, mais il faut souligner que le double est stocké en représentation de base 2 et que la base 2 ne peut pas représenter quelque chose d’aussi simple que 1.1 . Le seul moyen d’obtenir la précision complète du double réel (avec NO ROUND OFF ERROR) est d’imprimer les bits binarys (ou les nybbles hexadécimaux). Une façon de procéder consiste à écrire le double dans une union , puis à imprimer la valeur entière des bits.

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

Cela vous donnera la précision précise à 100% du double ... et sera totalement illisible car les humains ne peuvent pas lire le double format IEEE! Wikipedia a bien écrit sur la façon d'interpréter les bits binarys.

Dans C ++ plus récent, vous pouvez faire

 std::cout < < std::hexfloat << 1.1; 
 printf("%.12f", M_PI); 

% .12f signifie virgule flottante, avec une précision de 12 chiffres.

cout est un object qui contient un grand nombre de méthodes que vous pouvez appeler pour modifier la précision et le formatage des éléments imprimés.

Il y a une opération setprecision (…), mais vous pouvez aussi définir d’autres choses comme la largeur d’impression, etc.

Recherchez le cout dans la référence de votre IDE.

Plus portable …

 #include  using std::numeric_limits; ... cout.precision(numeric_limits::digits10 + 1); cout < < d; 

Avec ostream :: precision (int)

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

va céder

 3.141592653589793, 2.718281828459045 

Pourquoi vous devez dire "+1" Je n'ai aucune idée, mais le chiffre supplémentaire que vous en retirez est correct.