Lanciare un doppio come un int, lo fa circolare o semplicemente elimina le cifre?

Question

Esecuzione di alcuni calcoli con doppi che devono quindi essere convertiti in un int. Quindi ho una domanda veloce, quando lanci una doppia dire 7.5 a un int, essa restituirà 7.

Si tratta di un prodotto di arrotondamento o semplicemente striping di qualsiasi cosa dopo il punto decimale?

Se è un prodotto di arrotondamento, è intelligente cioè da 0,1 a 0,5 si arrotonda e da 0,6 a 0,9 viene arrotondato?

Acclamazioni

Answer 1

Esso non rotonda, restituisce solo la parte integrale prima della virgola.

Riferimento (grazie Rawling): Explicit Numeric Conversions Table

Si può provare a questioni semplici come questo da soli, scrivendo semplici test. Il seguente test (usando NUnit) passerà e quindi dare una risposta alla tua domanda:

[Test] 
public void Cast_float_to_int_will_not_round_but_truncate 
{ 
    var x = 3.9f; 
    Assert.That((int)x == 3); // <-- This will pass 
} 

Answer 2

Se si tratta di tornare 7 per un doppio di 7.5, allora non è arrotondamento, in quanto le regole di arrotondamento vorrebbe che nulla 5 e sopra arrotonda, non giù.

Answer 3

Prende la parte intera

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

il risultato è 0

Answer 4

Semplicemente colata solo rimuove tutto oltre il punto decimale. Per arrotondare verso l'alto o verso il basso, è possibile utilizzare Math.Round() method. Questo arrotonda o abbassa e fornisce un parametro su cosa fare se è a metà strada. È inoltre possibile utilizzare i metodi Math.Floor() o Math.Ceiling() per aggirare o arrotondare implicitamente prima del lancio. Ecco alcuni esempi:

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; 

Answer 5

Non lasciatevi ingannare assumendo che arrotonda per difetto. Rimuove la decimale e restituisce semplicemente la parte intera del doppio. Questo è importante con i numeri negativi perché arrotondare per difetto da 2,75 ti dà 2, ma arrotondando per difetto a -2,75 ti dare -3. Il cast non circoscrive così (int) 2.75 dà 2, ma (int) -2.75 ti dà -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 

Answer 6

Dal C# Language Specification:

In un unchecked contesto, la conversione riesce sempre, e procede come segue.

• Se il valore dell'operando è NaN o infinito, , il risultato della conversione è un valore non specificato del tipo di destinazione .

• In caso contrario, l'operando della sorgente viene arrotondato allo zero al valore integrale più vicino. Se questo valore integrale è compreso nell'intervallo del tipo di destinazione entro , questo valore è il risultato della conversione .

• In caso contrario, il risultato della conversione è un valore non specificato del tipo di destinazione .

Vedere anche Explicit Numeric Conversions Table — Remarks su MSDN.

Answer 7

Un cast normale come questo

int number; 
double decimals = 7.8987; 

number = (int)decimals; 

tornerà numero = 7. Questo è perché appena salta i numeri meno significativi. Se si vuole arrotondare correttamente è possibile utilizzare Math.round() come questo:

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

Ciò restituirà numero = 8.