Perché Decimal.Divide (int, int) funziona, ma non (int / int)?

Come mai dividere due numeri int a 32 bit come (int / int) ritorna 0, ma se uso Decimal.Divide()ottengo la risposta corretta? Non sono affatto un ragazzo #.

intè un tipo intero; la divisione di due interi esegue una divisione intera , cioè la parte frazionaria viene troncata poiché non può essere memorizzata nel tipo di risultato (anche int!). Decimal, al contrario, ha una parte frazionaria. Invocando Decimal.Divide, i tuoi intargomenti vengono convertiti implicitamente in Decimals.

È possibile applicare una divisione non intera sugli intargomenti eseguendo il cast esplicito di almeno uno degli argomenti in un tipo a virgola mobile, ad esempio:

int a = 42;
int b = 23;
double result = (double)a / b;

Nel primo caso, stai eseguendo una divisione intera, quindi il risultato viene troncato (la parte decimale viene troncata) e viene restituito un numero intero.

Nel secondo caso, gli interi vengono convertiti prima in decimali e il risultato è un decimale. Quindi non vengono troncati e ottieni il risultato corretto.

La riga seguente:

int a = 1, b = 2;
object result = a / b;

... verrà eseguito utilizzando l' aritmetica dei numeri interi . Decimal.Divided'altra parte accetta due parametri del tipo Decimal, quindi la divisione verrà eseguita su valori decimali invece che su valori interi. Questo è equivalente a questo:

int a = 1, b = 2;
object result = (Decimal)a / (Decimal)b;

Per esaminarlo, è 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

Immagino che Decimal.Divide(decimal, decimal)converta implicitamente i suoi 2 argomenti int in decimali prima di restituire un valore decimale (preciso) dove 4/5 viene trattato come divisione intera e restituisce 0

Vuoi trasmettere i numeri:

doppia c = (doppia) a / (doppia) b;

Nota: se uno degli argomenti in C # è un doppio, viene utilizzata una doppia divisione che si traduce in un doppio. Quindi, funzionerebbe anche quanto segue:

doppia c = (doppia) 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 una risposta 0 <a <1, int / int non sarà sufficiente. int / int esegue la divisione intera. Prova a lanciare uno degli int a un doppio all'interno dell'operazione.

Nel mio caso niente 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 ---> 0%: 51,6521739130435 -> 297/575 ---> 0

se moltiplico PeopleCount per 1.0 lo rende decimale e la divisione sarà 48.34 ... anche moltiplico per 100.0 non 100.

La risposta contrassegnata come tale è molto vicina, ma penso che valga la pena aggiungere che c'è una differenza tra l'uso di double e decimal.

Non farei un lavoro migliore di Wikipedia per spiegare i concetti, quindi fornirò solo i puntatori:

aritmetica in virgola mobile

tipo di dati decimale

Nei sistemi finanziari, è spesso un requisito poter garantire un certo numero di cifre decimali (base 10). Questo è generalmente impossibile se i dati di input / sorgente sono in base-10 ma eseguiamo l'aritmetica in base-2 (perché il numero di cifre decimali richieste per l'espansione decimale di un numero dipende dalla base; un terzo richiede infiniti decimali posti per esprimere in base-10 come 0,333333 ..., ma ci vuole solo un decimale in base-3: 0,1).

I numeri in virgola mobile sono più veloci da lavorare (in termini di tempo della CPU; dal punto di vista della programmazione sono ugualmente semplici) e preferiti ogni volta che si desidera ridurre al minimo l'errore di arrotondamento (come nelle applicazioni scientifiche).