Types numériques à virgule flottante (Référence C#)

Les types numériques à virgule flottante représentent des nombres réels. Les types numériques à virgule flottante sont des types de valeur. Ils sont également des types simples et peuvent être initialisés avec des littéraux. Tous les types numériques à virgule flottante prennent en charge les opérateurs arithmétiques et les opérateurs de comparaison et d’égalité.

Caractéristiques des types à virgule flottante

C# prend en charge les types à virgule flottante prédéfinis suivants :

Dans le tableau précédent, chaque mot clé de type C# de la colonne la plus à gauche est un alias pour le type .NET correspondant. Ils sont interchangeables. Par exemple, les déclarations suivantes déclarent des variables du même type :

double a = 12.3;
System.Double b = 12.3;

La valeur par défaut pour tous les types virgule flottante est zéro, 0. Chacun des types à virgule flottante a les constantes MinValue et MaxValue qui fournissent la valeur finie minimale et maximale de ce type. Les types float et double fournissent également des constantes qui représentent des valeurs NaN (Not-a-Number) et d’infini. Par exemple, le type double fournit les constantes suivantes : Double.NaN, Double.NegativeInfinity et Double.PositiveInfinity.

Le type decimal est approprié lorsque le degré de précision requis est déterminé par le nombre de chiffres à droite du point décimal. Ces nombres sont couramment utilisés dans les applications financières, pour les montants monétaires (par exemple, 1,00 $), les taux d’intérêt (par exemple, 2,625 %) et ainsi de suite. Même les nombres qui sont précis à un seul chiffre décimal sont gérés avec plus de précision par le type decimal : 0,1, par exemple, peut être représenté exactement par une instance decimal, alors qu’il n’y a aucune instance double ou float qui représente exactement 0,1. En raison de cette différence dans les types numériques, des erreurs d’arrondi inattendues peuvent se produire dans les calculs arithmétiques lorsque vous utilisez double ou float pour des données décimales. Vous pouvez utiliser double au lieu de decimal lorsque l’optimisation des performances est plus importante que la garantie de la précision. Toutefois, toute différence de performance passerait inaperçue par toutes les applications, sauf les applications les plus gourmandes en calculs. Une autre raison possible d’éviter decimal est de réduire les besoins en stockage. Par exemple, ML.NET utilise float, car la différence entre 4 et 16 octets s’additionne pour les jeux de données très volumineux. Pour plus d’informations, consultez System.Decimal.

Vous pouvez combiner des types intégraux et des types float et double dans une expression. Dans ce cas, les types intégraux sont convertis implicitement en un des types à virgule flottante et, si nécessaire, le type float est implicitement converti endouble. L'expression est évaluée de la manière suivante :

• S’il y a un type double dans l’expression, celle-ci prend la valeur double ou bool dans les comparaisons relationnelles ou les comparaisons d’égalité.
• S’il n’y a aucun type double dans l’expression, celle-ci prend la valeur float ou bool dans les comparaisons relationnelles ou les comparaisons d’égalité.

Vous pouvez combiner des types intégraux et le type decimal dans une expression. Dans ce cas, les types intégraux sont implicitement convertis en type decimal et l’expression est évaluée en decimal, ou en bool dans les comparaisons relationnelles et d’égalité.

Vous ne pouvez pas mélanger le type decimal avec les types float et double dans une expression. Dans ce cas, si vous souhaitez effectuer des opérations arithmétiques, de comparaison ou d’égalité, vous devez explicitement convertir les opérandes à partir du type decimal, comme le montre l’exemple suivant :

double a = 1.0;
decimal b = 2.1m;
Console.WriteLine(a + (double)b);
Console.WriteLine((decimal)a + b);

Vous pouvez utiliser des chaînes au format numérique standard ou des chaînes au format numérique personnalisées pour mettre en forme une valeur à virgule flottante.

Littéraux réels

Le type d’un littéral réel est déterminé par son suffixe comme suit :

• Le littéral sans suffixe ou avec le suffixe d ou D est de type double
• Le littéral avec le suffixe f ou F est de type float
• Le littéral avec le suffixe m ou M est de type decimal

Le code suivant illustre un exemple de chaque :

double d = 3D;
d = 4d;
d = 3.934_001;

float f = 3_000.5F;
f = 5.4f;

decimal myMoney = 3_000.5m;
myMoney = 400.75M;

L’exemple précédent montre également l’utilisation de _ comme séparateur de chiffres. Vous pouvez utiliser le séparateur de chiffres avec tous types de littéraux numériques.

Vous pouvez également utiliser la notation scientifique, c’est-à-dire, spécifier une partie exposante d’un littéral réel, comme le montre l’exemple suivant :

double d = 0.42e2;
Console.WriteLine(d);  // output 42

float f = 134.45E-2f;
Console.WriteLine(f);  // output: 1.3445

decimal m = 1.5E6m;
Console.WriteLine(m);  // output: 1500000

Conversions

Il n’existe qu’une seule conversion implicite entre les types numériques à virgule flottante : de float à double. Toutefois, vous pouvez convertir n’importe quel type à virgule flottante en n’importe quel autre type à virgule flottante avec le cast explicite. Pour plus d’informations, consultez Conversions numériques intégrées.

spécification du langage C#

Pour plus d’informations, consultez les sections suivantes de la spécification du langage C# :

• Types virgule flottante
• Type décimal
• Littéraux réels

Voir aussi

• Types de valeur
• Types intégraux
• Chaînes de format numériques standard
• Valeurs numériques dans .NET
• System.Numerics.Complex