Por que Decimal.Divide (int, int) funciona, mas não (int / int)?

Por que dividir dois números int de 32 bits como (int / int) retorna para mim 0, mas se eu usar Decimal.Divide(), obtenho a resposta correta? Não sou um cara c #.

inté um tipo inteiro; dividir dois ints realiza uma divisão inteira , ou seja, a parte fracionária é truncada, pois não pode ser armazenada no tipo de resultado (também int!). Decimal, ao contrário, tem uma parte fracionária. Ao invocar Decimal.Divide, seus intargumentos são convertidos implicitamente em Decimals.

Você pode impor a divisão não inteira em intargumentos convertendo explicitamente pelo menos um dos argumentos em um tipo de ponto flutuante, por exemplo:

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

No primeiro caso, você está fazendo uma divisão inteira, então o resultado é truncado (a parte decimal é cortada) e um inteiro é retornado.

No segundo caso, os ints são convertidos em decimais primeiro, e o resultado é um decimal. Portanto, eles não são truncados e você obtém o resultado correto.

A seguinte linha:

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

... será executado usando aritmética inteira . Decimal.Dividepor outro lado, leva dois parâmetros do tipo Decimal, então a divisão será realizada em valores decimais em vez de valores inteiros. Isso é equivalente a isto:

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

Para examinar isso, você pode adicionar as seguintes linhas de código após cada um dos exemplos acima:

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

A saída no primeiro caso será

0
System.Int32

..e no segundo caso:

0,5
System.Decimal

Acho que Decimal.Divide(decimal, decimal)converte implicitamente seus 2 argumentos int em decimais antes de retornar um valor decimal (preciso), onde 4/5 é tratado como divisão inteira e retorna 0

Você deseja lançar os números:

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

Nota: Se algum dos argumentos em C # for duplo, uma dupla divisão será usada, resultando em uma dupla. Portanto, o seguinte também funcionaria:

duplo c = (duplo) a / b;

aqui está um pequeno programa:

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 você está procurando 0 <a <1 resposta, int / int não será suficiente. int / int faz divisão inteira. Tente converter um dos int em um duplo dentro da operação.

No meu caso, nada funcionou acima.

o que eu quero fazer é dividir 278 por 575 e multiplicar por 100 para encontrar a porcentagem.

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

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

se eu multiplicar o PeopleCount por 1,0, torna-se decimal e a divisão será 48,34 ... multiplique também por 100,0, não 100.

A resposta marcada como tal está quase lá, mas acho que vale a pena acrescentar que há uma diferença entre usar duplo e decimal.

Eu não faria um trabalho melhor explicando os conceitos do que a Wikipedia, então irei apenas fornecer as dicas:

aritmética de ponto flutuante

tipo de dados decimais

Em sistemas financeiros, é freqüentemente um requisito que possamos garantir um certo número de (base 10) casas decimais de precisão. Isso geralmente é impossível se os dados de entrada / fonte estão na base 10, mas fazemos a aritmética na base 2 (porque o número de casas decimais necessárias para a expansão decimal de um número depende da base; um terço leva infinitas casas decimais casas para expressar na base 10 como 0,333333 ..., mas leva apenas uma casa decimal na base 3: 0,1).

Os números de ponto flutuante são mais rápidos de se trabalhar (em termos de tempo de CPU; em termos de programação, eles são igualmente simples) e preferidos sempre que você quiser minimizar o erro de arredondamento (como em aplicativos científicos).