Définir une précision décimale dans le langage C

Cet article vous montrera comment définir une précision décimale dans le langage de programmation C. Tout d'abord, nous définirons la précision, puis, nous examinerons plusieurs exemples pour montrer comment définir une précision décimale dans la programmation C.

Précision décimale en c

La variable de type entier est normalement utilisée pour maintenir la variable de type nombre et flottante pour maintenir les nombres réels avec des pièces fractionnaires, par exemple, 2.449561 ou -1.0587. La précision détermine la précision des nombres réels et est indiqué par le point (.) symbole. L'exactitude ou la précision des nombres réels est indiqué par le nombre de chiffres après le point décimal. Ainsi, la précision signifie le nombre de chiffres mentionnés après le point décimal du numéro de flotteur. Par exemple, le numéro 2.449561 a la précision six et -1.058 a la précision trois.

Selon la représentation des points flottants IEEE-754 à un seul précis. Sur les 32 bits, le bit le plus significatif est utilisé comme bit de signe, les 8 bits suivants sont utilisés comme exposant, et les 23 bits suivants sont utilisés comme fraction.

Dans le cas de la représentation des points flottants à double précision IEEE-754, il y a un total de 64 bits pour stocker le nombre réel. Sur les 64 bits, le bit le plus significatif est utilisé comme bit de signe, les 11 bits suivants sont utilisés comme exposant, et les 52 bits suivants sont utilisés comme fraction.

Cependant, lors de l'impression des nombres réels, il est nécessaire de spécifier la précision (en d'autres termes, la précision) du nombre réel. Si la précision n'est pas spécifiée, la précision par défaut sera prise en compte, je.e., Six chiffres décimaux après le point décimal. Dans les exemples suivants, nous vous montrerons comment spécifier la précision lors de l'impression des nombres à virgule flottante dans le langage de programmation C.

Exemples

Maintenant que vous avez une compréhension de base de la précision, regardons quelques exemples:

1. 1. Précision par défaut pour le flotteur
   2. Précision par défaut pour le double
   3. Définir la précision du flotteur
   4. Définir la précision pour le double

Exemple 1: Précision par défaut pour le flotteur

Cet exemple montre que la précision par défaut est définie sur six chiffres après le point décimal. Nous avons initialisé une variable flottante avec la valeur 2.7 et l'a imprimé sans spécifier explicitement la précision.

Dans ce cas, le paramètre de précision par défaut garantira que six chiffres après le point décimal sont imprimés.

#inclure
int main()

flotter f = 2.7;
printf ("\ nvalue de f =% f \ n", f);
printf ("taille de float =% ld \ n", sizeof (float));
retour 0;

Exemple 2: précision par défaut pour le double

Dans cet exemple, vous verrez que la précision par défaut est définie sur six chiffres après le point décimal pour les variables de type double. Nous avons initialisé une double variable, je.e., D, avec la valeur 2.7 et l'a imprimé sans spécifier la précision. Dans ce cas, le paramètre de précision par défaut garantira que six chiffres après le point décimal sont imprimés.

#inclure
int main()

double d = 2.7;
printf ("\ nvalue de d =% lf \ n", d);
printf ("taille de double =% ld \ n", sizeof (double));
retour 0;

Exemple 3: définissez la précision pour le flotteur

Maintenant, nous allons vous montrer comment définir la précision des valeurs flottantes. Nous avons initialisé une variable flottante, je.e., f, avec la valeur 2.7, et l'a imprimé avec divers paramètres de précision. Quand nous mentionnons «% 0.4f ”Dans la déclaration printf, cela indique que nous sommes intéressés à imprimer quatre chiffres après le point décimal.

#inclure
int main()

flotter f = 2.7;
/ * définir la précision pour la variable de flotteur * /
printf ("\ nvalue de f (précision = 0.1) =% 0.1f \ n ", f);
printf ("\ nvalue de f (précision = 0.2) =% 0.2f \ n ", f);
printf ("\ nvalue de f (précision = 0.3) =% 0.3f \ n ", f);
printf ("\ nvalue de f (précision = 0.4) =% 0.4f \ n ", f);
printf ("\ nvalue de f (précision = 0.22) =% 0.22f \ n ", f);
printf ("\ nvalue de f (précision = 0.23) =% 0.23f \ n ", f);
printf ("\ nvalue de f (précision = 0.24) =% 0.24f \ n ", f);
printf ("\ nvalue de f (précision = 0.25) =% 0.25f \ n ", f);
printf ("\ nvalue de f (précision = 0.40) =% 0.40f \ n ", f);
printf ("taille de float =% ld \ n", sizeof (float));
retour 0;

Exemple 4: définissez la précision pour le double

Dans cet exemple, nous verrons comment définir la précision pour les doubles valeurs. Nous avons initialisé une double variable, je.e., D, avec la valeur 2.7 et imprimé avec divers paramètres de précision. Quand nous mentionnons «% 0.52f ”Dans la déclaration printf, cela indique que nous sommes intéressés à imprimer 52 chiffres après le point décimal.

#inclure
int main()

flotter f = 2.7;
/ * définir la précision pour la variable de flotteur * /
printf ("\ nvalue de f (précision = 0.1) =% 0.1f \ n ", f);
printf ("\ nvalue de f (précision = 0.2) =% 0.2f \ n ", f);
printf ("\ nvalue de f (précision = 0.3) =% 0.3f \ n ", f);
printf ("\ nvalue de f (précision = 0.4) =% 0.4f \ n ", f);
printf ("\ nvalue de f (précision = 0.22) =% 0.22f \ n ", f);
printf ("\ nvalue de f (précision = 0.23) =% 0.23f \ n ", f);
printf ("\ nvalue de f (précision = 0.24) =% 0.24f \ n ", f);
printf ("\ nvalue de f (précision = 0.25) =% 0.25f \ n ", f);
printf ("\ nvalue de f (précision = 0.40) =% 0.40f \ n ", f);
printf ("taille de float =% ld \ n", sizeof (float));
retour 0;

Conclusion

La précision est un facteur très important pour représenter un nombre réel avec une précision adéquate. Le langage de programmation C fournit le mécanisme pour contrôler la précision ou l'exactitude d'un nombre réel. Cependant, nous ne pouvons pas modifier la précision réelle du nombre réel. Par exemple, la partie de fraction d'un numéro de point flottant à un seul précision 32 bits est représentée par 23 bits, et ceci est fixé; Nous ne pouvons pas changer cela pour un système particulier. Nous ne pouvons décider que la précision que nous voulons en définissant la précision souhaitée du nombre réel. Si nous avons besoin de plus de précision, nous pouvons toujours utiliser le numéro de point flottant à double précision 64 bits.