Quels sont les types numériques à virgule flottante en C #
En programmation, le terme «point flottant» fait référence à un type de données numériques utilisées pour représenter les nombres décimaux. Il existe plusieurs types de données à virgule flottante que vous pouvez utiliser en C #, chacune avec son propre ensemble de caractéristiques et de capacités.
Dans cet article, nous examinerons de plus près les types numériques à virgule flottante en C #.
Comprendre les types de données numériques
Avant de discuter du type de données à virgule flottante, il est important d'avoir une compréhension de base des différents types de données numériques disponibles en C #. Les données numériques couramment utilisées comprennent:
- Entier: Utilisé pour représenter les nombres (E.g., 1, 2, 3, etc.).
- Point flottant: Utilisé pour représenter les nombres décimaux (E.g., 1.2, 3.14, etc.).
- Décimal: Utilisé pour représenter des nombres avec une précision plus élevée que les nombres à virgule flottante (e.g., 3.14159265358979323846).
Maintenant, comme nous le savons, le point flottant est utilisé pour stocker les données décimales à l'intérieur. L'étape suivante consiste à discuter de toutes les différentes formes de nombres à virgule flottante.
Les bases des données à virgule flottante
Les données à virgule flottante sont utilisées pour représenter des nombres décimaux qui ne peuvent pas être représentés avec précision à l'aide de données entières. Par exemple, si vous souhaitez représenter le numéro 1.5 En utilisant des données entières, vous devrez l'arrondir ou vers le bas jusqu'à la valeur la plus proche (1 ou 2). Cependant, avec des données à virgule flottante, vous pouvez représenter 1.5 exactement.
Voici les types de points flottants utilisés en C # pour représenter des valeurs décimales avec différentes gammes et niveaux de précision.
- flotter: Il s'agit d'un type de données à virgule flottante 32 bits
- double: Il s'agit d'un type de données à virgule flottante 64 bits
- décimal: Il s'agit d'un type de données à virgule flottante 128 bits
Dans les trois types de données à virgule flottante, la décimale est d'une précision plus élevée.
Caractéristiques des types de données à virgule flottante
Les types numériques à virgule flottante en C # sont utilisés pour représenter des nombres qui ont une partie fractionnaire. Le tableau suivant illustre les caractéristiques de différents types de données à virgule flottante en C #:
| Types de données à virgule flottante | Gamme | Précision | Taille |
|---|---|---|---|
| flotter | ± 1.5 x 10−45 à ± 3.4 x 1038 | ~ 6-9 chiffres | 4 octets [32 bits] |
| double | ± 5.0 × 10−324 à ± 1.7 × 10308 | ~ 15-17 chiffres | 8 octets [64 bits] |
| décimal | ± 1.0 x 10-28 à ± 7.9228 x 1028 | 28-29 chiffres | 16 octets [128 bits] |
Par défaut, chacun de ces trois points flottants a des valeurs égales à zéro. Chacun d'eux a une valeur minimale et maximale.
En utilisant des données à virgule flottante en C #
Pour déclarer une variable flottante, vous pouvez utiliser la syntaxe suivante:
float myfloat = 3.14F;
Notez que vous devez ajouter le suffixe F à la valeur pour indiquer qu'il s'agit d'un flotteur.
Pour déclarer une double variable, vous pouvez utiliser la syntaxe suivante:
double mydouble = 3.14
Par défaut, les littéraux à virgule flottante en C # sont traités comme double. Si vous souhaitez utiliser un littéral flottant, vous pouvez ajouter le suffixe F à la valeur.
Pour déclarer les littéraux décimaux, nous utilisons le suffixe M ou M:
décimal myDecimal = 3.14m;
Comprendre les problèmes de précision à virgule flottante
La précision des nombres à virgule flottante en C # est limitée par le nombre de bits utilisés pour représenter le nombre. Par exemple, un numéro de point flottant (Float) utilise 32 bits pour représenter le nombre, tandis qu'un numéro de point flottant (double) utilise 64 bits.
Une conséquence de cette précision limitée est que toutes les valeurs décimales ne peuvent pas être représentées exactement à l'aide de nombres à virgule flottante. Par exemple, la valeur 0.1 ne peut pas être déclaré en utilisant des nombres à virgule flottante. Cela peut conduire à un comportement inattendu lors de l'exécution d'opérations arithmétiques.
Un autre problème est que certaines opérations peuvent introduire des erreurs d'arrondi. Par exemple, l'ajout de deux très petits nombres peut entraîner une perte de précision. De même, la soustraction de deux très grands nombres peut également entraîner une perte de précision.
Par exemple, considérez le code suivant:
double num1 = 0.1;
double num2 = 0.2;
Double résultat = num1 + num2;
Vous pourriez vous attendre à ce que la valeur du résultat soit 0.3, mais en raison de la façon dont les données à virgule flottante sont stockées, la valeur réelle du résultat sera légèrement différente (dans ce cas, elle sera d'environ 0.30000000000000004). Des résultats comme ceux-ci peuvent modifier la sortie et peuvent provoquer un comportement inattendu dans le programme, il est donc important d'être conscient de ces problèmes de précision.
Pour résoudre ces problèmes, les types de données décimaux peuvent être préférés au flotteur et double. La décimale a une précision plus élevée que le double et est meilleure pour représenter des valeurs qui nécessitent un degré élevé de précision.
Conclusion
Les types de données à virgule flottante peuvent stocker des nombres avec une précision différente. Les trois principaux types incluent le flotteur, le double et la décimale. Parmi tous, la décimale a la plus haute précision. En utilisant ces types de points flottants en C #, on peut facilement représenter des nombres décimaux. Pour une description détaillée des trois types, lisez l'article.