Perché la divisione intera in C # restituisce un numero intero e non un float?

Qualcuno sa perché la divisione intera in C # restituisce un numero intero e non un float? Qual è l'idea alla base? (È solo un'eredità di C / C ++?)

In C #:

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

Il risultato di questo codice sarebbe:

'Hello world'

A rigor di termini, non esiste una divisione intera (la divisione per definizione è un'operazione che produce un numero razionale, i cui numeri interi sono un sottoinsieme molto piccolo.)

Mentre è comune per il nuovo programmatore fare questo errore nell'eseguire la divisione di interi quando in realtà intendevano usare la divisione in virgola mobile, nella pratica la divisione di interi è un'operazione molto comune. Se stai assumendo che le persone lo usino raramente e che ogni volta che fai divisione devi sempre ricordarti di lanciare in virgola mobile, ti sbagli.

Prima di tutto, la divisione intera è un po 'più veloce, quindi se hai bisogno solo di un numero intero, vorrai utilizzare l'algoritmo più efficiente.

In secondo luogo, ci sono un certo numero di algoritmi che utilizzano la divisione di numeri interi e se il risultato della divisione era sempre un numero in virgola mobile, si sarebbe costretti a arrotondare il risultato ogni volta. Un esempio fuori dalla cima della mia testa sta cambiando la base di un numero. Il calcolo di ogni cifra implica la divisione intera di un numero insieme al resto, anziché la divisione in virgola mobile del numero.

A causa di questi (e altri motivi correlati), la divisione dei numeri interi risulta in un numero intero. Se vuoi ottenere la divisione in virgola mobile di due numeri interi, dovrai solo ricordarti di lanciarne uno in double/ float/ decimal.

Vedi le specifiche C # . Esistono tre tipi di operatori di divisione

• Divisione intera
• Divisione in virgola mobile
• Divisione decimale

Nel tuo caso abbiamo la divisione Integer, con le seguenti regole applicate:

La divisione arrotonda il risultato a zero e il valore assoluto del risultato è il numero intero più grande possibile che è inferiore al valore assoluto del quoziente dei due operandi. Il risultato è zero o positivo quando i due operandi hanno lo stesso segno e zero o negativo quando i due operandi hanno segni opposti.

Penso che il motivo per cui C # usi questo tipo di divisione per gli interi (alcune lingue restituiscono risultati fluttuanti) è l'hardware - la divisione degli interi è più veloce e più semplice.

Ogni tipo di dati è in grado di sovraccaricare ciascun operatore. Se sia il numeratore che il denominatore sono numeri interi, il tipo intero eseguirà l'operazione di divisione e restituirà un tipo intero. Se si desidera la divisione in virgola mobile, è necessario eseguire il cast di uno o più dei numeri in tipi in virgola mobile prima di dividerli. Per esempio:

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

oppure, se stai usando valori letterali:

float x = 13f / 4f;

Tieni presente che i punti fluttuanti non sono precisi. Se ti interessa la precisione, usa invece qualcosa come il tipo decimale.

Dato che non usi alcun suffisso, i letterali 13e 4vengono interpretati come numeri interi:

Manuale :

Se il letterale non ha suffisso, ha il primo di questi tipi in cui il suo valore può essere rappresentato: int, uint, long, ulong.

Pertanto, poiché si dichiara 13come intero, verrà eseguita la divisione dei numeri interi:

Manuale :

Per un'operazione nel formato x / y, viene applicata la risoluzione di sovraccarico dell'operatore binario per selezionare un'implementazione specifica dell'operatore. Gli operandi vengono convertiti nei tipi di parametri dell'operatore selezionato e il tipo del risultato è il tipo di ritorno dell'operatore.

Gli operatori di divisione predefiniti sono elencati di seguito. Tutti gli operatori calcolano il quoziente di xe y.

Divisione intera:

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 così si verifica l'arrotondamento:

La divisione arrotonda il risultato a zero e il valore assoluto del risultato è il numero intero più grande possibile che è inferiore al valore assoluto del quoziente dei due operandi. Il risultato è zero o positivo quando i due operandi hanno lo stesso segno e zero o negativo quando i due operandi hanno segni opposti.

Se esegui le seguenti operazioni:

int x = 13f / 4f;

Riceverai un errore del compilatore, poiché una divisione in virgola mobile (l' /operatore di 13f) genera un float, che non può essere implicitamente lanciato.

Se vuoi che la divisione sia una divisione in virgola mobile, dovrai rendere il risultato un float:

float x = 13 / 4;

Si noti che continuerai a dividere numeri interi, che verranno implicitamente lanciati su float: il risultato sarà 3.0. Per dichiarare esplicitamente gli operandi come float, usando il fsuffisso ( 13f, 4f).

È solo un'operazione di base .

Ricorda quando hai imparato a dividere. All'inizio abbiamo risolto 9/6 = 1 with remainder 3.

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

L'operatore / in combinazione con l'operatore% viene utilizzato per recuperare quei valori.

Potrebbe essere utile:

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

Il risultato sarà sempre di tipo con la gamma maggiore del numeratore e del denominatore. Le eccezioni sono byte e short, che producono 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

Non esiste una conversione implicita tra i tipi a virgola mobile e il tipo decimale, quindi la divisione tra di essi non è consentita. Devi espressamente lanciare e decidere quale vuoi (Decimale ha più precisione e un intervallo più piccolo rispetto ai tipi a virgola mobile).