Le C ++ double précision en virgule flottante de variable

La variable à virgule flottante standard C ++ est son grand frère, le double précision

Sommaire

virgule flottante ou simplement double. Vous déclarez une double précision en virgule flottante comme suit:

à double dValue1 double dValue2 = 1,5

Les limites de la int variables en C ++ sont inacceptables dans certaines applications. Heureusement, C ++ comprend des nombres décimaux qui ont une partie fractionnaire. (Mathématiciens appellent ces nombres réels.) En C ++, les nombres décimaux sont appelés nombres à virgule flottante ou simplement flotteurs. Ceci parce que le point décimal peut flotter autour de gauche à droite pour gérer les valeurs fractionnaires.

Les variables à virgule flottante viennent dans deux saveurs de base en C ++. La petite variété est déclaré en utilisant le mot-clé flotteur comme suit:

flotter fValue1 - // déclarer une pointfloat flottante fValue2 = 1,5 // initialiser lors de la déclaration

Résoudre le problème de troncature

Pour voir comment le double fixe notre problème de troncature, considérer la moyenne des trois variables à virgule flottante dValue1, dValue2, et dValue3 donné par la formule

à double BDMOYENNE = dValue1 / 3.0 + dValue2 / 3.0 + dValue3 / 3.0-

Supposons, une fois de plus, les valeurs initiales de 1,0, 2,0, et 2,0. Cela rend l'expression vient de donner ici comme équivalent à

à double BDMOYENNE = 1.0 / 3.0 + 2.0 / 3.0 + 2.0 / 3.0-

qui est, à son tour, soit

à double BDMOYENNE = 0,333 ... + 0,6666 + 0,6666 ... ...-

résultant en une valeur finale de

à double BDMOYENNE = 1.666 ...-

Les expressions précédentes sont écrites comme si il y avait un nombre infini de Sixes après la virgule. En fait, ce ne est pas le cas. La précision d'une double est limité à environ 14 chiffres significatifs. La différence entre 1,666666666666 et 1 2/3 est faible, mais pas nul.

Quand un nombre entier est un nombre entier non

C ++ suppose que d'un nombre suivi par un point décimal est une constante à virgule flottante. Ainsi, il suppose que 2.5 est un point flottant. Cette règle de point décimal est vrai même si la valeur à la droite de la virgule décimale est égale à zéro. Ainsi 3.0 est également un point flottant. La distinction entre 3 et 3.0 semble petit pour vous, mais pas à C ++.

En fait, vous ne disposez pas de mettre quoi que ce soit à la droite de la virgule. Ainsi C ++ voit aussi comme un 3. double. Cependant, il est considéré comme un bon style pour inclure le 0 après la virgule pour toutes les constantes à virgule flottante.

Voilà qui va être intéressé de savoir que les représentations internes de 3 et 3.0 sont totalement différentes (bâillement). Plus important encore, la constante int 3 est soumis à int règles, alors que 3.0 est soumis aux règles de l'arithmétique flottante.

Ainsi, vous devriez essayer d'éviter des expressions comme les suivantes:


à double dValue = 1.0 double dOneThird = dValue / 3-

Techniquement, cela est ce qui est connu comme un en mode mixte parce expression dValue est un double mais figure 3 est une int. Ok, C ++ est pas une idiote - il sait ce que vous voulez dans un cas comme celui-ci, il convertit le 3 à un double et effectue l'arithmétique flottante.

Il ya un nom pour ce peu de magie: C ++ favorise la int 3 à un double. C ++ vous permet également d'attribuer un résultat en virgule flottante à une int variables:

int nValue = dValue / 3.0-

Attribution d'un double à un int qui est connu comme un rétrogradation.

Les compilateurs C Certains génèrent un avertissement lors de la promotion d'une variable. Les compilateurs C Tout génèrent un avertissement (ou erreur) lors de la rétrogradation à la suite en raison de la perte de précision.

Vous devriez prendre l'habitude d'éviter en mode mixte arithmétique. Si vous devez changer le type d'une expression, faire explicitement en utilisant un casting, comme dans l'exemple suivant:

fn (int Narg) {// calculer un tiers de nArg- utiliser un casting pour // le promouvoir à un flottant pointdouble dOneThird = (double) Narg / 3.0 - // ... fonction continue

La convention de nommage de commencer les variables doubles double précision par la lettre est utilisé ici. Qui est simplement une convention. Vous pouvez nommer vos variables comme vous le souhaitez - C ++ ne se soucie pas.


» » » » Le C ++ double précision en virgule flottante de variable