Bibliothèque standard C -<float.h>
Introduction
<float.h>est un fichier d’en-tête de la bibliothèque standard C qui définit des macros liées aux types à virgule flottante (float、doubleetlong double) macros associées. Ces macros fournissent les caractéristiques et les limites des nombres à virgule flottante, telles que la valeur maximale, la valeur minimale, la précision, etc.
de la bibliothèque standard Cfloat.hLe fichier d’en-tête contient un ensemble de constantes dépendantes de la plateforme liées aux valeurs à virgule flottante. Ces constantes ont été introduites par ANSI C, ce qui rend les programmes plus portables. Avant d’expliquer ces constantes, il est préférable de comprendre d’abord que les nombres à virgule flottante sont composés des quatre éléments suivants :
| Composants | description du composant |
|---|---|
| S | Symbole ( +/- ) |
| b | La base de la représentation de l’exposant, 2 pour binaire, 10 pour décimal, 16 pour hexadécimal, etc. |
| e | exposant, un entier compris entre la valeur minimaleeminet la valeur maximaleemax. |
| p | précision, le nombre de chiffres significatifs en base b |
Basé sur les 4 composants ci-dessus, la valeur d'un nombre à virgule flottante est la suivante :
nombre à virgule flottante = ( S ) p x be
ou
nombre à virgule flottante = (+/-) précision x baseexposant
Macros de bibliothèque
Les valeurs suivantes sont spécifiques à l'implémentation et sont définies via la directive #define. Ces valeurs ne doivent pas être inférieures aux valeurs données ci-dessous. Notez que dans tous les cas FLT fait référence au type float, DBL fait référence au type double, et LDBL fait référence au type long double.
Nombre à virgule flottante en simple précision (float)
FLT_RADIX: la base (ou radix) du nombre à virgule flottante (généralement 2).FLT_MANT_DIG：floatNombre de chiffres significatifs pour le type.FLT_DIG：floatLa précision décimale du type, c'est-à-dire le nombre maximal de chiffres décimaux pouvant être garantis sans perte.FLT_MIN_EXP：floatL'exposant négatif minimal du type (en base radix).FLT_MIN_10_EXP：floatExposant décimal négatif minimal pour le type.FLT_MAX_EXP：floatL'exposant maximal du type (en base radix).FLT_MAX_10_EXP：floatExposant décimal maximal pour le type.FLT_MAX：floatValeur positive maximale pour le type.FLT_MIN：floatValeur positive minimale pour le type.FLT_EPSILON：floatL'erreur relative du type, c'est-à-dire la différence entre 1.0 et le plus petit nombre à virgule flottante supérieur à 1.0.
Nombre à virgule flottante à double précision (double)
DBL_MANT_DIG：doubleNombre de chiffres significatifs pour le type.DBL_DIG：doublePrécision décimale pour le type.DBL_MIN_EXP：doubleL'exposant négatif minimal du type (en base radix).DBL_MIN_10_EXP：doubleExposant décimal négatif minimal pour le type.DBL_MAX_EXP：doubleL'exposant maximal du type (en base radix).DBL_MAX_10_EXP：doubleExposant décimal maximal pour le type.DBL_MAX：doubleValeur positive maximale pour le type.DBL_MIN：doubleValeur positive minimale pour le type.DBL_EPSILON：doubleErreur relative pour le type.
Nombre à virgule flottante à précision étendue (long double)
LDBL_MANT_DIG：long doubleNombre de chiffres significatifs pour le type.LDBL_DIG：long doublePrécision décimale pour le type.LDBL_MIN_EXP：long doubleL'exposant négatif minimal du type (en base radix).LDBL_MIN_10_EXP：long doubleExposant décimal négatif minimal pour le type.LDBL_MAX_EXP：long doubleL'exposant maximal du type (en base radix).LDBL_MAX_10_EXP：long doubleExposant décimal maximal pour le type.LDBL_MAX：long doubleValeur positive maximale pour le type.LDBL_MIN：long doubleValeur positive minimale pour le type.LDBL_EPSILON：long doubleErreur relative pour le type.
Exemple
L'exemple suivant illustre l'utilisation de certaines constantes définies dans le fichier d'en-tête float.h.
Exemple
#include <float.h>
int main() {
printf("Simple précision (float):\n");
printf("FLT_RADIX: %d\n", FLT_RADIX);
printf("FLT_MANT_DIG: %d\n", FLT_MANT_DIG);
printf("FLT_DIG: %d\n", FLT_DIG);
printf("FLT_MIN_EXP: %d\n", FLT_MIN_EXP);
printf("FLT_MIN_10_EXP: %d\n", FLT_MIN_10_EXP);
printf("FLT_MAX_EXP: %d\n", FLT_MAX_EXP);
printf("FLT_MAX_10_EXP: %d\n", FLT_MAX_10_EXP);
printf("FLT_MAX: %e\n", FLT_MAX);
printf("FLT_MIN: %e\n", FLT_MIN);
printf("FLT_EPSILON: %e\n", FLT_EPSILON);
printf("\nDouble précision (double):\n");
printf("DBL_MANT_DIG: %d\n", DBL_MANT_DIG);
printf("DBL_DIG: %d\n", DBL_DIG);
printf("DBL_MIN_EXP: %d\n", DBL_MIN_EXP);
printf("DBL_MIN_10_EXP: %d\n", DBL_MIN_10_EXP);
printf("DBL_MAX_EXP: %d\n", DBL_MAX_EXP);
printf("DBL_MAX_10_EXP: %d\n", DBL_MAX_10_EXP);
printf("DBL_MAX: %e\n", DBL_MAX);
printf("DBL_MIN: %e\n", DBL_MIN);
printf("DBL_EPSILON: %e\n", DBL_EPSILON);
printf("\nPrécision étendue (long double) :\n");
printf("LDBL_MANT_DIG: %d\n", LDBL_MANT_DIG);
printf("LDBL_DIG: %d\n", LDBL_DIG);
printf("LDBL_MIN_EXP: %d\n", LDBL_MIN_EXP);
printf("LDBL_MIN_10_EXP: %d\n", LDBL_MIN_10_EXP);
printf("LDBL_MAX_EXP: %d\n", LDBL_MAX_EXP);
printf("LDBL_MAX_10_EXP: %d\n", LDBL_MAX_10_EXP);
printf("LDBL_MAX: %Le\n", LDBL_MAX);
printf("LDBL_MIN: %Le\n", LDBL_MIN);
printf("LDBL_EPSILON: %Le\n", LDBL_EPSILON);
return 0;
}
Compilons et exécutons le programme ci-dessus, ce qui produira le résultat suivant :
Single precision (float): FLT_RADIX: 2 FLT_MANT_DIG: 24 FLT_DIG: 6 FLT_MIN_EXP: -125 FLT_MIN_10_EXP: -37 FLT_MAX_EXP: 128 FLT_MAX_10_EXP: 38 FLT_MAX: 3.402823e+38 FLT_MIN: 1.175494e-38 FLT_EPSILON: 1.192093e-07 Double precision (double): DBL_MANT_DIG: 53 DBL_DIG: 15 DBL_MIN_EXP: -1021 DBL_MIN_10_EXP: -307 DBL_MAX_EXP: 1024 DBL_MAX_10_EXP: 308 DBL_MAX: 1.797693e+308 DBL_MIN: 2.225074e-308 DBL_EPSILON: 2.220446e-16 Extended precision (long double): LDBL_MANT_DIG: 64 LDBL_DIG: 18 LDBL_MIN_EXP: -16381 LDBL_MIN_10_EXP: -4931 LDBL_MAX_EXP: 16384 LDBL_MAX_10_EXP: 4932 LDBL_MAX: 1.189731e+4932 LDBL_MIN: 3.362103e-4932 LDBL_EPSILON: 1.084202e-19
<float.h>Fournit un ensemble de macros pour décrire les caractéristiques et les limitations des types à virgule flottante. En utilisant ces macros, nous pouvons écrire du code plus robuste pour gérer les cas limites et les situations particulières liées aux nombres à virgule flottante.