significado - ¿Por qué la división de enteros en C#devuelve un número entero y no un flotante?

que es double en informatica

Question

¿Alguien sabe por qué la división entera en C # devuelve un número entero y no un flotante? ¿Cuál es la idea detrás de esto? (¿Es solo un legado de C / C ++?)

Cª#:

float x = 13 / 4;   
//imagine I used have an overridden == operator here to use epsilon compare
if (x == 3.0)
   print ''Hello world'';

El resultado de este código sería:

''Hello world''

Estrictamente hablando, no existe la división de enteros (la división por definición es una operación que produce un número racional, los enteros son un subconjunto muy pequeño del cual).

Answer 1

Cada tipo de datos puede sobrecargar a cada operador. Si tanto el numerador como el denominador son enteros, el tipo entero realizará la operación de división y devolverá un tipo entero. Si desea la división de punto flotante, debe convertir uno o más de los números en coma flotante antes de dividirlos. Por ejemplo:

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

o, si está usando literales:

float x = 13f / 4f;

Tenga en cuenta que los puntos flotantes no son precisos. Si te preocupa la precisión, utiliza algo como el tipo decimal, en su lugar.

Answer 2

Como no usa ningún sufijo, los literales 13 y 4 se interpretan como un entero:

Manual :

Si el literal no tiene sufijo, tiene el primero de estos tipos en que se puede representar su valor: int , uint , long , ulong .

Por lo tanto, como declaras 13 como un número entero, se realizará una división entera:

specification :

Para una operación de la forma x / y, se aplica la resolución de sobrecarga del operador binario para seleccionar una implementación de operador específica. Los operandos se convierten a los tipos de parámetros del operador seleccionado, y el tipo de resultado es el tipo de retorno del operador.

Los operadores de división predefinidos se enumeran a continuación. Todos los operadores calculan el cociente de x y y.

División entera:

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

Y así ocurre el redondeo:

La división redondea el resultado hacia cero, y el valor absoluto del resultado es el entero más grande posible que es menor que el valor absoluto del cociente de los dos operandos. El resultado es cero o positivo cuando los dos operandos tienen el mismo signo y cero o negativo cuando los dos operandos tienen signos opuestos.

Si haces lo siguiente:

int x = 13f / 4f;

Recibirá un error de compilación, ya que una división de coma flotante (el / operador de 13f ) da como resultado un flotante, que no se puede convertir a int implícitamente.

Si quieres que la división sea una división de coma flotante, tendrás que hacer que el resultado sea flotante:

float x = 13 / 4;

Observe que aún dividirá enteros, los cuales se convertirán implícitamente en flotantes: el resultado será 3.0 . Para declarar explícitamente los operandos como flotantes, usando el sufijo f ( 13f , 4f ).

Answer 3

El resultado siempre será del tipo que tenga el mayor rango del numerador y el denominador. Las excepciones son byte y short, que producen 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

No hay conversión implícita entre los tipos de punto flotante y el tipo decimal, por lo que no se permite la división entre ellos. Tienes que lanzar explícitamente y decidir cuál quieres (el decimal tiene más precisión y un rango menor en comparación con los de coma flotante).

Answer 4

Es solo una operación básica .

Recuerda cuando aprendiste a dividir. Al principio 9/6 = 1 with remainder 3 .

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

El / -operator en combinación con el% -operator se usa para recuperar esos valores.

Answer 5

Puede 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

Answer 6

Si bien es común que un programador nuevo cometa este error al realizar una división de enteros cuando en realidad querían usar la división de coma flotante, en la práctica la división de enteros es una operación muy común. Si estás asumiendo que las personas rara vez lo usan, y que cada vez que haces una división siempre necesitarás recordar lanzar a puntos flotantes, estás equivocado.

En primer lugar, la división entera es bastante más rápida, por lo que si solo necesitas un número entero, querrás usar el algoritmo más eficiente.

En segundo lugar, hay una serie de algoritmos que utilizan la división de enteros, y si el resultado de la división era siempre un número de coma flotante, se lo obligaría a redondear el resultado cada vez. Un ejemplo fuera de mi cabeza es cambiar la base de un número. El cálculo de cada dígito implica la división entera de un número junto con el resto, en lugar de la división del número en coma flotante.

Debido a estas (y otras razones relacionadas), la división entera da como resultado un número entero. Si desea obtener la división de punto flotante de dos enteros, solo tendrá que recordar lanzar uno a un double / float / decimal .

Answer 7

Ver la specification C #. Hay tres tipos de operadores de división

• División entera
• División de punto flotante
• División decimal

En su caso, tenemos la división Integer, con las siguientes reglas aplicadas:

La división redondea el resultado hacia cero, y el valor absoluto del resultado es el entero más grande posible que es menor que el valor absoluto del cociente de los dos operandos. El resultado es cero o positivo cuando los dos operandos tienen el mismo signo y cero o negativo cuando los dos operandos tienen signos opuestos.

Creo que la razón por la cual C # usa este tipo de división para enteros (algunos idiomas arrojan resultados flotantes) es hardware: la división de enteros es más rápida y simple.