Почему целочисленное деление в C # возвращает целое число, а не число с плавающей запятой?

Кто-нибудь знает, почему целочисленное деление в C # возвращает целое число, а не число с плавающей запятой? В чем идея? (Это только наследие C / C ++?)

В C #:

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

Результатом этого кода будет:

'Hello world'

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

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

Во-первых, целочисленное деление происходит немного быстрее, поэтому, если вам нужен только результат целого числа, можно использовать более эффективный алгоритм.

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

По этим (и другим связанным) причинам целочисленное деление дает целое число. Если вы хотите получить деление двух целых чисел с плавающей запятой, вам просто нужно не забыть привести одно к double/ float/ decimal.

См. Спецификацию C # . Есть три типа операторов деления

• Целочисленное деление
• Деление с плавающей точкой
• Десятичное деление

В вашем случае у нас есть целочисленное деление со следующими правилами:

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

Я думаю, что причина, по которой C # использует этот тип деления для целых чисел (некоторые языки возвращают плавающий результат), аппаратная - деление целых чисел происходит быстрее и проще.

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

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

или, если вы используете литералы:

float x = 13f / 4f;

Имейте в виду, что числа с плавающей запятой неточны. Если вам важна точность, используйте вместо этого что-то вроде десятичного типа.

Поскольку вы не используете суффикс, литералы 13и 4интерпретируются как целые числа:

Руководство :

Если буквальное не имеет суффикса, он имеет первый из этих типов , в которых его значение может быть представлено: int, uint, long, ulong.

Таким образом, поскольку вы объявляете 13целое число, будет выполнено целочисленное деление:

Руководство :

Для операции формы x / y применяется разрешение перегрузки бинарного оператора, чтобы выбрать конкретную реализацию оператора. Операнды преобразуются в типы параметров выбранного оператора, а тип результата - это тип, возвращаемый оператором.

Предварительно определенные операторы деления перечислены ниже. Все операторы вычисляют частное x и y.

Целочисленное деление:

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

И так происходит округление в меньшую сторону:

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

Если вы сделаете следующее:

int x = 13f / 4f;

Вы получите ошибку компилятора, поскольку деление с плавающей запятой ( / оператор of 13f) приводит к получению числа с плавающей запятой, которое не может быть неявно преобразовано в int.

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

float x = 13 / 4;

Обратите внимание, что вы по-прежнему делите целые числа, которые неявно будут преобразованы в float: результат будет 3.0. Чтобы явно объявить операнды как float, используя fсуффикс ( 13f, 4f).

Это просто базовая операция .

Вспомните, когда вы научились делить. Вначале мы решили 9/6 = 1 with remainder 3.

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

Оператор / в сочетании с оператором% используются для получения этих значений.

Может быть полезно:

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

Результат всегда будет иметь тип, который имеет больший диапазон числителя и знаменателя. Исключения бывают байтовыми и короткими, что дает 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

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