Чому ціле ділення в C # повертає ціле число, а не float?

Хтось знає, чому ціле ділення в C # повертає ціле число, а не float? Яка ідея стоїть за ним? (Це лише спадщина 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 # . Існує три типи операторів поділу

• Ціле ділення
• Поділ з плаваючою комою
• Десятковий поділ

У вашому випадку у нас є підрозділ Integer із застосованими наступними правилами:

Ділення округляє результат до нуля, і абсолютне значення результату є найбільшим можливим цілим числом, меншим за абсолютне значення коефіцієнта двох операндів. Результат дорівнює нулю або позитиву, коли обидва операнди мають однаковий знак і нуль або мінус, коли два операнди мають протилежні знаки.

Я думаю, що причина, чому 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;

Ви отримаєте помилку компілятора, оскільки поділ з плаваючою комою ( /оператор 13f) призводить до поплавця, який не можна привласнювати неявно.

Якщо ви хочете, щоб поділ був поділом з плаваючою комою, вам доведеться зробити результат поплавком:

float x = 13 / 4;

Зауважте, що ви все одно розділите цілі числа, які буде неявно закинуто плавати: результат буде 3.0. Щоб явно оголосити операнди як плаваючі, використовуючи 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

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