Lancer un double en tant qu'int, arrondit-il ou simplement dépouille-t-il les chiffres?
Faire quelques calculs avec des doubles qui doivent ensuite être convertis en entier. J'ai donc une question rapide, lors du casting d'un double disons 7,5 à un int, il retournera 7.
S'agit-il d'un produit arrondi ou simplement rayé après la virgule décimale?
S'il s'agit d'un produit d'arrondi, est-il intelligent, c'est-à-dire 0,1 à 0,5, il arrondit et 0,6 à 0,9, il arrondit?
À votre santé
Il ne s'arrondit pas, il renvoie juste la partie intégrale avant le point décimal.
Référence (merci Rawling ) Tableau des conversions numériques explicites :
Lorsque vous convertissez une valeur double ou flottante en type intégral, cette valeur est arrondie vers zéro à la valeur intégrale la plus proche.
Vous pouvez essayer vous-même des problèmes simples comme celui-ci en écrivant des tests simples. Le test suivant (en utilisant NUnit ) passera et donnera donc une réponse à votre question:
[Test]
public void Cast_float_to_int_will_not_round_but_truncate
{
var x = 3.9f;
Assert.That((int)x == 3); // <-- This will pass
}
Ne vous laissez pas berner en supposant qu'il arrondit. Il supprime la décimale et renvoie purement la partie entière du double. Ceci est important avec des nombres négatifs car l'arrondi à partir de 2,75 vous donne 2, mais l'arrondi à partir de -2,75 vous donne -3. Le lancer ne s'arrondit pas, donc (int) 2,75 donne 2, mais (int) -2,75 vous donne -2.
double positiveDouble = 2.75;
double negativeDouble = -2.75;
int positiveInteger = (int) positiveDouble;
int negativeInteger = (int) negativeDouble;
Console.WriteLine(positiveInteger + " = (int)" + positiveDouble);
Console.WriteLine(negativeInteger + " = (int)" + negativeDouble);
Console.ReadLine();
//Output: 2 = (int)2.75
// -2 = (int)-2.75
Le simple fait de couler supprime tout ce qui dépasse la virgule décimale. Pour arrondir vers le haut ou vers le bas, vous pouvez utiliser la méthode Math.Round () . Cela arrondira vers le haut ou vers le bas et fournit un paramètre sur ce qu'il faut faire si c'est à mi-chemin. Vous pouvez également utiliser les méthodes Math.Floor () ou Math.Ceiling () pour arrondir ou arrondir implicitement avant la conversion. Voici quelques exemples:
double num1 = 3.5;
double num2 = 3.2;
double num3 = 3.9;
(int)num1 // returns 3;
(int)num2 // returns 3;
(int)num3 // returns 3 also;
(int)Math.Round(num1) // returns 4
(int)Math.Round(num2) // returns 3
(int)Math.Round(num3) // returns 4
(int)Math.Floor(num1) // returns 3
(int)Math.Floor(num2) // returns 3
(int)Math.Floor(num3) // returns 3
(int)Math.Ceiling(num1) // returns 4
(int)Math.Ceiling(num2) // returns 4;
(int)Math.Ceiling(num3) // returns 4;
Il prend la partie entière
double d = 0.9;
System.Console.WriteLine((int)d);
le résultat est 0
Un casting normal comme celui-ci
int number;
double decimals = 7.8987;
number = (int)decimals;
renverra number = 7. C'est parce qu'il saute juste les nombres les moins significatifs. Si vous voulez qu'il arrondisse correctement, vous pouvez utiliser Math.Round () comme ceci:
number = (int)Math.Round(number);
Cela renverra le nombre = 8.
S'il renvoie 7 pour un double de 7,5, il ne s'agit pas d'un arrondi, car les règles d'arrondi imposent que tout ce qui est supérieur ou égal à 5 arrondisse, pas à la baisse.
De la Spécification du langage C # :
Dans un contexte
unchecked, la conversion réussit toujours et se déroule comme suit.• Si la valeur de l'opérande est NaN ou infinie, le résultat de la conversion est une valeur non spécifiée du type de destination.
• Sinon, l'opérande source est arrondi vers zéro à la valeur intégrale la plus proche. Si cette valeur intégrale se situe dans la plage du type de destination, cette valeur est le résultat de la conversion.
• Sinon, le résultat de la conversion est une valeur non spécifiée du type de destination.
Voir aussi Tableau de conversions numériques explicites - Remarques sur MSDN.