C # 'da tamsayı bölme neden bir tamsayı döndürür ve kayan nokta döndürmez?

C # 'da tamsayı bölümünün neden bir float değil de tamsayı döndürdüğünü bilen var mı? Arkasındaki fikir nedir? (Yalnızca bir C / C ++ mirası mı?)

C # dilinde:

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

Bu kodun sonucu şöyle olacaktır:

'Hello world'

Açıkçası, tamsayı bölme diye bir şey yoktur (tanıma göre bölme, rasyonel bir sayı üreten bir işlemdir, tamsayılar çok küçük bir alt kümedir.)

Yeni programcı için tamsayı bölme yapma hatasını gerçekte kayan nokta bölmesini kullanmak istediklerinde yapmaları yaygın olsa da, gerçek uygulamada tamsayı bölme çok yaygın bir işlemdir. İnsanların onu nadiren kullandığını ve her bölme yaptığınızda her zaman kayan noktalara atmayı hatırlamanız gerekeceğini varsayıyorsanız, yanılıyorsunuz.

Öncelikle, tamsayı bölme biraz daha hızlıdır, bu nedenle yalnızca bir tam sayı sonucuna ihtiyacınız varsa, daha verimli algoritmayı kullanmak isteyebilirsiniz.

İkinci olarak, tamsayı bölme kullanan bir dizi algoritma vardır ve bölmenin sonucu her zaman bir kayan nokta sayısı ise, her seferinde sonucu yuvarlamak zorunda kalırsınız. Kafamın üstünden bir örnek, bir sayının tabanını değiştirmektir. Her bir basamağın hesaplanması, sayının kayan nokta bölümü yerine, bir sayının tamsayı bölümü ile kalanı içerir.

Bu (ve diğer ilgili) nedenlerden dolayı, tamsayı bölme bir tamsayı ile sonuçlanır. İki tam sayının kayan nokta bölümünü elde etmek istiyorsanız, sadece birini a double/ float/' ye dönüştürmeyi hatırlamanız gerekir decimal.

C # spesifikasyonuna bakın . Üç tür bölüm operatörü vardır

• Tamsayı bölümü
• Kayan nokta bölümü
• Ondalık bölme

Sizin durumunuzda, aşağıdaki kuralların uygulandığı Tamsayı bölmesine sahibiz:

Bölme, sonucu sıfıra yuvarlar ve sonucun mutlak değeri, iki işlenenin bölümünün mutlak değerinden daha küçük olan olası en büyük tam sayıdır. İki işlenen aynı işarete sahipse sonuç sıfır veya pozitif ve iki işlenen zıt işaretlere sahip olduğunda sıfır veya negatiftir.

Bence C # 'ın tamsayılar için bu tür bir bölme kullanmasının nedeni (bazı diller kayan sonuç döndürür) donanımdır - tamsayılar bölümü daha hızlı ve daha basittir.

Her veri türü, her operatörü aşırı yükleyebilir. Hem pay hem de payda tamsayı ise, tamsayı türü bölme işlemini gerçekleştirecek ve bir tam sayı türü döndürecektir. Kayan noktalı bölme istiyorsanız, sayılardan birini veya daha fazlasını, bölmeden önce kayan nokta türlerine çevirmelisiniz. Örneğin:

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

veya değişmez değerler kullanıyorsanız:

float x = 13f / 4f;

Unutmayın, kayan noktalar kesin değildir. Hassasiyeti önemsiyorsanız, bunun yerine ondalık tür gibi bir şey kullanın.

Herhangi bir son ek kullanmadığınız için, değişmezler 13ve 4tamsayı olarak yorumlanır:

Kılavuzu :

Değişmezi hiçbir eki varsa, bu değeri temsil edilebilir ki bu tür ilk sahiptir: int, uint, long, ulong.

Böylece, 13tamsayı olarak ilan ettiğiniz için , tamsayı bölme işlemi gerçekleştirilecektir:

Kılavuzu :

X / y formundaki bir işlem için, belirli bir operatör uygulamasını seçmek için ikili operatör aşırı yük çözümlemesi uygulanır. İşlenenler, seçilen işlecin parametre türlerine dönüştürülür ve sonucun türü, işlecin dönüş türüdür.

Önceden tanımlanmış bölüm operatörleri aşağıda listelenmiştir. Operatörlerin tümü x ve y'nin bölümünü hesaplar.

Tamsayı bölümü:

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

Ve böylece aşağı yuvarlama gerçekleşir:

Bölme, sonucu sıfıra yuvarlar ve sonucun mutlak değeri, iki işlenenin bölümünün mutlak değerinden daha küçük olan olası en büyük tam sayıdır. İki işlenen aynı işarete sahipse sonuç sıfır veya pozitif ve iki işlenen zıt işaretlere sahip olduğunda sıfır veya negatiftir.

Aşağıdakileri yaparsanız:

int x = 13f / 4f;

Bir kayan nokta bölümü ( /operatörü 13f), dolaylı olarak int'e dönüştürülemeyen bir kayan nokta ile sonuçlandığından , bir derleyici hatası alırsınız .

Bölümün bir kayan nokta bölümü olmasını istiyorsanız, sonucu bir kayan nokta yapmanız gerekir:

float x = 13 / 4;

Tam sayıları yine böleceğinize dikkat edin, bu örtük olarak float'a dönüştürülür: sonuç olacaktır 3.0. Son feki ( 13f, 4f) kullanarak işlenenleri float olarak açıkça bildirmek için .

Bu sadece basit bir işlem .

Bölmeyi öğrendiğiniz zamanı hatırlayın. Başlangıçta çözdük 9/6 = 1 with remainder 3.

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

% -Operator ile birlikte / -operatör bu değerleri almak için kullanılır.

Yararlı olabilir:

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

Sonuç her zaman pay ve payda için daha geniş bir aralığa sahip türden olacaktır. İstisnalar bayt ve kısadır ve int (Int32) üretir.

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

Kayan nokta türleri ve ondalık tür arasında örtük dönüştürme yoktur, bu nedenle aralarında bölmeye izin verilmez. Hangisini istediğinizi açıkça çevirmeniz ve karar vermeniz gerekir (Ondalık, kayan nokta türlerine kıyasla daha fazla hassasiyete ve daha küçük bir aralığa sahiptir).