Impression double contenu de variable
J'ai essayé extrait de code suivant et de sortie est de me surprendre:
#include <stdio.h>
#include <math.h>
int main()
{
double num;
unsigned char ch;
ch = 19;
num = 1.0E+20 ;
num += ch * 1.0E+18;
printf("E18 = %lf \n",num);
printf("E18 = %e \n",num);
num = 11.0E+21 ;
num += ch * 1.0E+19;
printf("E19 = %lf <------\n",num);
printf("E19 = %e <------\n",num);
num = 11.0E+22 ;
num += ch * 1.0E+20;
printf("E20 = %lf\n",num);
printf("E20 = %e\n",num);
num = 11.0E+23 ;
num += ch * 1.0E+21;
printf("E21 = %lf\n",num);
printf("E21 = %e\n",num);
num = 11.0E+24 ;
num += ch * 1.0E+22;
printf("E22 = %lf <------\n",num);
printf("E22 = %e <------\n",num);
return 0;
}
La sortie du programme:
E18 = 119000000000000000000.000000
E18 = 1.190000e+20
E19 = 11190000000000000524288.000000 <------
E19 = 1.119000e+22 <------
E20 = 111900000000000001048576.000000
E20 = 1.119000e+23
E21 = 1119000000000000044040192.000000
E21 = 1.119000e+24
E22 = 11189999999999999366660096.000000 <------
E22 = 1.119000e+25 <------
Pourquoi les données de endommagé lors de l'impression, tout en exposant son OK
OriginalL'auteur Adil | 2010-03-24
Vous devez vous connecter pour publier un commentaire.
Parce que, vous le perdez en précision lorsque le nombre de croître assez grand : http://en.wikipedia.org/wiki/Floating_point
OriginalL'auteur Tuomas Pelkonen
Les données ne sont pas corrompues; c'est tout simplement la façon dont les valeurs de virgule flottante de travail dans les ordinateurs d'aujourd'hui. Pensez à un flotteur comme un fixe nombre de chiffres (de la mantisse) et un autre numéro qui indique l'emplacement du point décimal doit être placé (l'exposant). Pour le long et le plus précis de l'histoire, Wikipédia est un bon début.
Puisque le nombre de chiffres de la mantisse est fixe, il ne peut pas représenter la fraction infime de ce que vous proposez ici. En outre, parce que c'est tout en binaire, décimal les nombres ne peuvent pas toujours être représenté exactement.
La notation exponentielle simplement arrondit les derniers chiffres dont le nombre est connu pour être inexactes, d'où vos résultats.
OriginalL'auteur Thomas
Double/nombres à virgule flottante perdre de précision car ils deviennent de plus en plus - en plus de l'article de Wikipedia Tuomas a posté, voici une autre bonne:
http://www.yoda.arachsys.com/csharp/floatingpoint.html
Il était destiné à .NET, mais le principe s'applique toujours.
OriginalL'auteur Andy Shellam
De données à virgule flottante types d'utiliser un nombre fini de bits pour représenter une certaine gamme de valeurs. Cependant, il peut y avoir un nombre infini de valeurs entre deux nombres réels m et n. Donc, vous sacrifier la précision.
Il semble bien, en exposant forme depuis pas tous les chiffres sont en cours d'impression.
de test, essayez d'imprimer la valeur de 0,2 à environ 10 décimales et vous verrez que la valeur stockée est plus comme 0.1999999....OriginalL'auteur Agnel Kurian
Vous voyez l'imprécision inhérente à virgule flottante.
Certains
printf
conversions sont garantis pour produire assez de chiffres significatifs pour identifier le numéro en cours d'impression. Cela implique que, s'il en est pour toute imprécision, vous allez le voir. À l'inverse, la valeur par défaut%e
/%f
représentation se cache l'imprécision par arrondissement.Autant que je sache,
%a
(hexadécimal à virgule flottante) est la seule façon d'atteindre cet objectif. Selon POSIX spec,%lf
est défini à faire la même chose que%f
, qui est,Donc c'est techniquement un bug dans votre bibliothèque standard.
OriginalL'auteur Potatoswatter