Perché funziona Decimal.Divide (int, int), ma non (int / int)?
Domanda
Come mai dividere due numeri int a 32 bit come (int / int) mi ritorna 0
, ma se uso Decimal.Divide()
ottengo la risposta corretta? Non sono affatto un ragazzo c #.
Soluzione
int
è un tipo intero; la divisione di due ints esegue una divisione intera , ovvero la parte frazionaria viene troncata poiché non può essere memorizzata nel tipo di risultato (anche Decimal
!). Decimal.Divide
, al contrario, ha una parte frazionaria. Invocando <=>, i tuoi <=> argomenti vengono convertiti implicitamente in <=> s.
Puoi applicare una divisione non intera su <=> argomenti eseguendo esplicitamente il cast di almeno uno degli argomenti in un tipo a virgola mobile, ad es .:
int a = 42;
int b = 23;
double result = (double)a / b;
Altri suggerimenti
Nel primo caso, stai eseguendo la divisione di numeri interi, quindi il risultato viene troncato (la parte decimale viene troncata) e viene restituito un numero intero.
Nel secondo caso, gli ints vengono prima convertiti in decimali e il risultato è un decimale. Quindi non vengono troncati e si ottiene il risultato corretto.
La seguente riga:
int a = 1, b = 2;
object result = a / b;
... verrà eseguito utilizzando numero intero aritmetico . Decimal.Divide
d'altra parte accetta due parametri del tipo Decimal
, quindi la divisione verrà eseguita su valori decimali anziché su valori interi. Questo è equivalente a questo:
int a = 1, b = 2;
object result = (Decimal)a / (Decimal)b;
Per esaminare questo, è possibile aggiungere le seguenti righe di codice dopo ciascuno degli esempi precedenti:
Console.WriteLine(result.ToString());
Console.WriteLine(result.GetType().ToString());
L'output nel primo caso sarà
0
System.Int32
..e nel secondo caso:
0,5
System.Decimal
Suppongo che Decimal.Divide(decimal, decimal)
converta implicitamente i suoi 2 argomenti in decimali prima di restituire un valore decimale (preciso) dove 4/5 viene trattato come divisione intera e restituisce 0
Vuoi lanciare i numeri:
double c = (double) a / (double) b;
Nota: se uno qualsiasi degli argomenti in C # è un doppio, viene utilizzato un doppio divario che risulta in un doppio. Quindi, funzionerebbe anche il seguente:
double c = (double) a / b;
ecco un piccolo programma:
static void Main(string[] args)
{
int a=0, b = 0, c = 0;
int n = Convert.ToInt16(Console.ReadLine());
string[] arr_temp = Console.ReadLine().Split(' ');
int[] arr = Array.ConvertAll(arr_temp, Int32.Parse);
foreach (int i in arr)
{
if (i > 0) a++;
else if (i < 0) b++;
else c++;
}
Console.WriteLine("{0}", (double)a / n);
Console.WriteLine("{0}", (double)b / n);
Console.WriteLine("{0}", (double)c / n);
Console.ReadKey();
}
Se stai cercando 0 < a < 1 risposta, int / int non sarà sufficiente. int / int fa la divisione intera. Prova a lanciare uno degli int in un doppio all'interno dell'operazione.
Nel mio caso nulla ha funzionato sopra.
quello che voglio fare è dividere 278 per 575 e moltiplicare per 100 per trovare la percentuale.
double p = (double)((PeopleCount * 1.0 / AllPeopleCount * 1.0) * 100.0);
%: 48,3478260869565 - > 278/575 --- & Gt; 0 %: 51.6521739130435 - & GT; 297/575 --- & Gt; 0
se moltiplico PeopleCount per 1.0, questo lo rende decimale e la divisione sarà 48.34 ... anche moltiplicare per 100,0 non 100.
La risposta contrassegnata come tale è quasi lì, ma penso che valga la pena aggiungere che c'è una differenza tra l'uso del doppio e del decimale.
Non farei un lavoro migliore spiegando i concetti di Wikipedia, quindi fornirò solo i suggerimenti:
Nei sistemi finanziari, spesso è necessario poter garantire un certo numero di decimali (base-10). Questo è generalmente impossibile se i dati di input / source sono in base-10 ma eseguiamo l'aritmetica in base-2 (perché il numero di posizioni decimali richiesto per l'espansione decimale di un numero dipende dalla base; un terzo prende infinitamente molti decimali posti da esprimere in base-10 come 0,333333 ..., ma richiede solo un decimale in base-3: 0,1).
I numeri in virgola mobile sono più veloci con cui lavorare (in termini di tempo della CPU; in termini di programmazione sono ugualmente semplici) e preferiti ogni volta che si desidera ridurre al minimo l'errore di arrotondamento (come nelle applicazioni scientifiche).