Question Lancer un double en int, arrondit-il ou simplement dénude les chiffres?


Faire des calculs avec des doubles qui doivent ensuite être convertis en int. Donc, j'ai une question rapide, lorsque vous lancez un double say 7.5 dans un int, il retournera 7.

Est-ce un produit d'arrondir ou de simplement rogner quelque chose après la virgule?

S'il s'agit d'un produit d'arrondi, est-ce intelligent, c'est-à-dire que 0,1 à 0,5 arrondit à la baisse et 0,6 à 0,9 qu'il arrondit?

À votre santé


18
2017-11-08 15:32


origine


Réponses:


Il ne arrondit pas, il retourne simplement la partie intégrale avant le point décimal.

Référence (merci Rawling): Table de conversions numériques explicites

Vous pouvez essayer 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
}

32
2017-11-08 15:33



Ne vous laissez pas berner en supposant que cela arrondit. Il supprime le nombre décimal et renvoie purement la partie entière du double. Ceci est important avec les nombres négatifs car arrondir à 2.75 vous donne 2, mais arrondir à -2.75 vous donne -3. Le cast ne 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

8
2017-11-08 15:42



Simplement lancer simplement tout ce qui dépasse le point décimal. Pour arrondir, vous pouvez utiliser le Méthode Math.Round (). Cela arrondit ou diminue et fournit un paramètre sur ce qu'il faut faire si c'est à mi-chemin. Vous pouvez également utiliser le Math.Floor () ou Math.Ceiling () méthodes pour arrondir ou arrondir implicitement avant le casting. 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;

8
2017-11-08 15:37



Il prend la partie entière

double d = 0.9;
System.Console.WriteLine((int)d);

le résultat est 0


4
2017-11-08 15:34



Si elle retourne 7 pour un double de 7,5, alors elle n’est pas arrondie, car des règles d’arrondi dicteraient que tout ce qui est au-dessus de 5 arrondit à la hausse et non à la baisse.


0
2017-11-08 15:34



Du Spécification du langage C #:

Dans un unchecked contexte, la conversion réussit toujours, et   procède 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 est dans   la plage du type de destination alors cette valeur est le résultat de la   conversion.

• Sinon, le résultat de la conversion est un   valeur non spécifiée du type de destination.

Voir également Table de conversions numériques explicites - Remarques sur MSDN.


0
2017-11-08 15:49



Un casting normal comme ça

int number;
double decimals = 7.8987;

number = (int)decimals;

renverra le nombre = 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 ça:

number = (int)Math.Round(number);

Cela retournera le nombre = 8.


0
2017-11-08 15:52