Почему Decimal.Divide (int, int) работает, а не (int / int)?

Question

Почему деление двух 32-битных чисел int как (int / int) возвращает мне 0, но если я использую Decimal.Divide(), я получу правильный ответ? Я ни в коем случае не парень с #.

Answer 1

int - целочисленный тип; деление двух целых чисел выполняет деление целое число , то есть дробная часть усекается, поскольку она не может быть сохранена в типе результата (также int!). Decimal, напротив, имеет дробную часть. При вызове Decimal.Divide ваши int аргументы неявно преобразуются в Decimal s.

Вы можете применить нецелочисленное деление для аргументов int, явно приведя хотя бы один из аргументов к типу с плавающей запятой, например ::

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

Answer 2

В первом случае вы выполняете целочисленное деление, поэтому результат усекается (десятичная часть отсекается) и возвращается целое число.

Во втором случае целые числа сначала преобразуются в десятичные, и в результате получается десятичное число. Следовательно, они не усекаются, и вы получите правильный результат.

Answer 3

Следующая строка:

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

... будет выполняться с использованием целочисленной арифметики . Decimal.Divide, с другой стороны, принимает два параметра типа Decimal, поэтому деление будет выполняться по десятичным, а не целым значениям. Это эквивалентно этому:

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

Чтобы проверить это, вы можете добавить следующие строки кода после каждого из приведенных выше примеров:

Console.WriteLine(result.ToString());
Console.WriteLine(result.GetType().ToString());

Выход в первом случае будет

0
System.Int32

.. а во втором случае:

0,5
System.Decimal

Answer 4

Я считаю Decimal.Divide(decimal, decimal) неявно преобразует свои 2 аргумента int в десятичные числа, прежде чем вернуть десятичное значение (точное), где 4/5 рассматривается как целочисленное деление и возвращает 0

Answer 5

Вы хотите разыграть числа:

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

Примечание: Если какой-либо из аргументов в C # является двойным, используется двойное деление, что приводит к двойному Таким образом, будет работать следующее:

двойной с = (двойной) а / б;

Вот небольшая программа:

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();
        }

Answer 6

В моем случае ничего не работало выше.

я хочу разделить 278 на 575 и умножить на 100, чтобы найти процент.

double p = (double)((PeopleCount * 1.0 / AllPeopleCount * 1.0) * 100.0);

%: 48,3478260869565 -> 278/575 ---> 0 %: 51,6521739130435 -> 297/575 ---> 0

если я умножу PeopleCount на 1,0, это будет десятичное число, и деление будет 48,34 также умножьте на 100,0, а не на 100.

Answer 7

Ответ, помеченный как таковой, очень близок, но я думаю, что стоит добавить, что есть разница между использованием двойного и десятичного.

Я бы не стал лучше объяснять понятия, чем Википедия, поэтому я просто предоставлю указатели:

арифметика с плавающей точкой

тип десятичных данных

В финансовых системах часто требуется, чтобы мы могли гарантировать точность определенного числа (основание-10) десятичных знаков. Это вообще невозможно, если входные / исходные данные находятся в base-10, но мы выполняем арифметику в base-2 (потому что количество десятичных разрядов, необходимое для десятичного разложения числа, зависит от основания; одна треть занимает бесконечно много десятичных места для выражения в base-10 как 0.333333 ..., но требуется только один десятичный знак в base-3: 0.1).

С числами с плавающей точкой работать быстрее (с точки зрения времени процессора; с точки зрения программирования они одинаково просты) и предпочтительнее, когда вы хотите минимизировать ошибку округления (как в научных приложениях).

Answer 8

Если вы ищете ответ 0