Type de données en langage C à virgule flottante

Point de connaissance 1 : type de données à virgule flottante

1) Les types de données à virgule flottante incluent float (virgule flottante simple précision), double (virgule flottante double précision), long double (virgule flottante longue précision).

2) Puisque la position décimale peut flotter, la forme exponentielle des nombres réels est appelée nombre à virgule flottante.

3) Étant donné qu'un nombre réel est représenté sous forme binaire et que la longueur de l'unité de stockage est limitée, il est impossible d'obtenir une valeur totalement précise et ne peut être stockée qu'avec une précision limitée. Plus la partie décimale occupe de bits , plus le nombre comporte de chiffres significatifs et plus la précision est élevée. Plus la partie exposant occupe de chiffres, plus la plage de valeurs pouvant être exprimées est large.

Point de connaissance 2 : La plage de valeurs des nombres à virgule flottante

Point de connaissance 3 : Représentation des nombres à virgule flottante

1) Forme décimale : composée de nombres et de points décimaux ;

Exemple : 3.14, 4., .4, .0, 0.

2) Forme exponentielle : "décimal décimal ou entier" + "e (ou E)" + "décimal entier". Il doit y avoir des nombres des deux côtés de e (ou E) et ne peut pas être omis.

Exemple : 3,5-4 signifie 3,5*10*(-4), 5,4E+8

3) Le type de nombre à virgule flottante simple précision n'a que 6 chiffres valides après la virgule décimale ;

4) Le nombre de chiffres significatifs du type nombre à virgule flottante double précision peut atteindre 16 bits ;

5) La plupart des compilateurs C stipulent qu'un maximum de 6 chiffres sont conservés après la virgule décimale et que les parties restantes sont arrondies ;

Point de connaissance 4 : Définition des nombres à virgule flottante

Grâce au délimiteur de type, vous pouvez définir une variable de type virgule flottante de la même manière que vous définissez une variable entière ;

Identifiant [définisseur de type] ;

numéro flottant ; double fond;

Les variables de type à virgule flottante peuvent également être générées à l'aide de la fonction printf(). La différence avec les variables entières est la suivante : l' élément de spécification de format de float est "%f" ; l'élément de spécification de format de double est "%f".

Point de connaissance 5 : Traitement des valeurs avec des décimales

#include <stdio.h>
int main()
{
int a = 1.234567;
int b = 0.00001;
int c = 365.12345;
printf("%d\n", a);
printf("%d\n", b);
printf("%d\n", c);
return 0;
}

Le résultat est 1 0 365. Autrement dit, la partie décimale est perdue ;

1) Nous remplaçons le type entier int dans le code ci-dessus par un float de type à virgule flottante simple précision. Après cela, l'espace réservé dans printf("%d\n",a); est %d, nous le remplaçons donc par %f. (L'espace réservé %d est utilisé pour les types entiers, l'espace réservé %f est utilisé pour les types à virgule flottante) ;

#include <stdio.h>
int main()
{
float a = 1.234567;
float b = 0.00001;
float c = 365.12345;
printf("%f\n", a);
printf("%f\n", b);
printf("%f\n", c);
return 0;
}
结果：1.2345567
      0.000010
      365.123444

2) Après avoir remplacé int par float, la plupart des données sont correctes. Mais 365,12345 est devenu 365,123444. Il est évident qu’il y a une erreur de précision. En effet, les nombres à virgule flottante ne peuvent pas représenter une précision infinie et il y aura certaines erreurs ;

3) La norme C stipule que le type float doit pouvoir représenter au moins 6 chiffres significatifs et que la plage de valeurs est d'au moins 10^-37~10+37. Par conséquent, lorsque vous utilisez float pour contenir 365,12345, les six premiers chiffres sont exacts, mais les valeurs suivantes sont légèrement inexactes ;

4) Nous remplaçons float dans le code ci-dessus par double ;

#include <stdio.h>
int main()
{
double a = 1.234567;
double b = 0.00001;
double c = 365.12345;
printf("%f\n", a);
printf("%f\n", b);
printf("%f\n", c);
return 0;
}
结果：1.234567
     0.000010
     365.123450

Cette fois, 365.12345 est également correct ;

* Le type double dispose également d'une plage de précision. S'il s'agit de données de plus grande précision, le double comportera également des erreurs ;

Point de connaissance 6 : La taille en octets occupée par les types à virgule flottante

#D' après notre expérience précédente avec les entiers, plus la gamme de types entiers est grande, plus l'espace qu'ils occupent est grand. Ainsi, pour les types à virgule flottante, plus la précision est élevée et plus la plage du type à virgule flottante est grande, plus l'espace doit être occupé. Nous utilisons sizeof pour mesurer combien d'espace float et double occupent respectivement.

#include <stdio.h>
int main()
{
printf("sizeof float = %d\n", sizeof(float));
printf("sizeof double = %d\n", sizeof(double));
return 0;
}
结果；sizeof float=4
      sizeof double=8

# float et double font respectivement 4 et 8 octets. Cela vérifie notre hypothèse précédente selon laquelle plus la plage est grande et plus la précision est élevée, plus l'espace occupé par le type est grand.