Por que a divisão inteira em C # retorna um número inteiro e não um número flutuante?

Alguém sabe por que a divisão inteira em C # retorna um número inteiro e não um float? Qual é a ideia por trás disso? (É apenas um legado de C / C ++?)

Em c #:

float x = 13 / 4;   
//== operator is overridden here to use epsilon compare
if (x == 3.0)
   print 'Hello world';

O resultado desse código seria:

'Hello world'

A rigor, não existe divisão inteira (divisão por definição é uma operação que produz um número racional, os números inteiros são um subconjunto muito pequeno).

Embora seja comum o novo programador cometer esse erro de executar a divisão inteira quando na verdade pretendia usar a divisão de ponto flutuante, na prática real a divisão inteira é uma operação muito comum. Se você está assumindo que as pessoas raramente o usam e que toda vez que faz uma divisão, sempre precisará se lembrar de lançar pontos flutuantes, está enganado.

Primeiro, a divisão inteira é um pouco mais rápida; portanto, se você precisar apenas de um resultado com um número inteiro, é recomendável usar o algoritmo mais eficiente.

Em segundo lugar, existem vários algoritmos que usam divisão inteira e, se o resultado da divisão sempre foi um número de ponto flutuante, você seria forçado a arredondar o resultado toda vez. Um exemplo em cima da minha cabeça é mudar a base de um número. O cálculo de cada dígito envolve a divisão inteira de um número junto com o restante, em vez da divisão de ponto flutuante do número.

Devido a esses (e outros motivos relacionados), a divisão inteira resulta em um inteiro. Se você deseja obter a divisão de ponto flutuante de dois números inteiros, basta lembrar de converter um em double/ float/ decimal.

Consulte a especificação C # . Existem três tipos de operadores de divisão

• Divisão inteira
• Divisão de ponto flutuante
• Divisão decimal

No seu caso, temos a divisão Inteiro, com as seguintes regras aplicadas:

A divisão arredonda o resultado para zero e o valor absoluto do resultado é o maior número inteiro possível que é menor que o valor absoluto do quociente dos dois operandos. O resultado é zero ou positivo quando os dois operandos têm o mesmo sinal e zero ou negativo quando os dois operandos têm sinais opostos.

Eu acho que a razão pela qual o C # usa esse tipo de divisão para números inteiros (algumas línguas retornam resultado flutuante) é o hardware - a divisão de números inteiros é mais rápida e mais simples.

Cada tipo de dados é capaz de sobrecarregar cada operador. Se o numerador e o denominador forem números inteiros, o tipo inteiro executará a operação de divisão e retornará um tipo inteiro. Se você deseja divisão de ponto flutuante, deve converter um ou mais números para tipos de ponto flutuante antes de dividi-los. Por exemplo:

int x = 13;
int y = 4;
float x = (float)y / (float)z;

ou, se você estiver usando literais:

float x = 13f / 4f;

Lembre-se de que os pontos flutuantes não são precisos. Se você se preocupa com precisão, use algo como o tipo decimal.

Como você não usa nenhum sufixo, os literais 13e 4são interpretados como número inteiro:

Manual :

Se o literal tem nenhum sufixo, tem o primeiro desses tipos em que o seu valor pode ser representados: int, uint, long, ulong.

Assim, como você declara 13como inteiro, a divisão inteira será realizada:

Manual :

Para uma operação no formato x / y, a resolução de sobrecarga do operador binário é aplicada para selecionar uma implementação específica do operador. Os operandos são convertidos nos tipos de parâmetro do operador selecionado e o tipo do resultado é o tipo de retorno do operador.

Os operadores de divisão predefinidos estão listados abaixo. Todos os operadores calculam o quociente de x e y.

Divisão inteira:

int operator /(int x, int y);
uint operator /(uint x, uint y);
long operator /(long x, long y);
ulong operator /(ulong x, ulong y);

E assim ocorre o arredondamento:

A divisão arredonda o resultado para zero e o valor absoluto do resultado é o maior número inteiro possível que é menor que o valor absoluto do quociente dos dois operandos. O resultado é zero ou positivo quando os dois operandos têm o mesmo sinal e zero ou negativo quando os dois operandos têm sinais opostos.

Se você fizer o seguinte:

int x = 13f / 4f;

Você receberá um erro do compilador, pois uma divisão de ponto flutuante (o /operador de 13f) resulta em um ponto flutuante, que não pode ser convertido para int implicitamente.

Se você deseja que a divisão seja uma divisão de ponto flutuante, terá que transformar o resultado em flutuante:

float x = 13 / 4;

Observe que você ainda dividirá números inteiros, que serão implicitamente convertidos para flutuar: o resultado será 3.0. Para declarar explicitamente os operandos como flutuante, usando o fsufixo ( 13f, 4f).

É apenas uma operação básica .

Lembre-se de quando você aprendeu a dividir. No começo nós resolvemos 9/6 = 1 with remainder 3.

9 / 6 == 1  //true
9 % 6 == 3 // true

O operador / em combinação com o operador% é usado para recuperar esses valores.

Pode ser útil:

double a = 5.0/2.0;   
Console.WriteLine (a);      // 2.5

double b = 5/2;   
Console.WriteLine (b);      // 2

int c = 5/2;   
Console.WriteLine (c);      // 2

double d = 5f/2f;   
Console.WriteLine (d);      // 2.5

O resultado será sempre do tipo que possui o maior intervalo do numerador e do denominador. As exceções são byte e short, que produzem int (Int32).

var a = (byte)5 / (byte)2;  // 2 (Int32)
var b = (short)5 / (byte)2; // 2 (Int32)
var c = 5 / 2;              // 2 (Int32)
var d = 5 / 2U;             // 2 (UInt32)
var e = 5L / 2U;            // 2 (Int64)
var f = 5L / 2UL;           // 2 (UInt64)
var g = 5F / 2UL;           // 2.5 (Single/float)
var h = 5F / 2D;            // 2.5 (Double)
var i = 5.0 / 2F;           // 2.5 (Double)
var j = 5M / 2;             // 2.5 (Decimal)
var k = 5M / 2F;            // Not allowed

Não há conversão implícita entre os tipos de ponto flutuante e o tipo decimal; portanto, a divisão entre eles não é permitida. É necessário converter e decidir explicitamente qual você deseja (o Decimal tem mais precisão e um intervalo menor comparado aos tipos de ponto flutuante).