Java neden imzalanmamış girişleri desteklemiyor?

Java neden imzasız tamsayılar için destek içermiyor?

Beklenmedik derecede büyük girdide taşma üretme olasılığı daha düşük olan kod yazmalarına izin verildiği için garip bir ihmal gibi görünüyor.

Ayrıca, imzasız tamsayıların kullanılması bir tür kendi kendine dokümantasyon olabilir, çünkü imzasız int'in sahip olması amaçlanan değerin asla negatif olması gerektiğini göstermezler.

Son olarak, bazı durumlarda, imzasız tamsayılar, bölme gibi belirli işlemler için daha verimli olabilir.

Bunları dahil etmenin dezavantajı nedir?

Bu Gosling ve diğerleriyle basitlik üzerine bir röportajdan :

Gosling: Benim için bugünlerde saymadığım bir dil tasarımcısı olarak benim için “basit” in gerçekten anlamı neydi? Bu tanım, örneğin, Java'nın olmadığını ve aslında bu dillerin çoğunun, kimsenin gerçekten anlamadığı şeylerle çok sayıda köşe vakası ile sonuçlandığını söylüyor. Herhangi bir C geliştiricisini imzasız hakkında test edin ve çok yakında neredeyse hiç C geliştiricisinin imzasız olanlarla ne olduğunu, imzasız aritmetiğin ne olduğunu anladığını keşfedersiniz. Bunun gibi şeyler C'yi karmaşık hale getirdi. Java'nın dil kısmı bence oldukça basit. Bakmanız gereken kütüphaneler.

Satır aralarını okurken mantığın şöyle bir şey olduğunu düşünüyorum:

• Java tasarımcıları genellikle mevcut veri türlerinin repertuarını basitleştirmek istedi
• günlük amaçlar için, en yaygın ihtiyacın imzalı veri türleri için olduğunu hissettiler
• bazı algoritmaları uygulamak için, imzasız aritmetik bazen gereklidir, ancak bu tür algoritmaları uygulayacak programcılar da imzalı veri türleriyle imzasız aritmetik yaparak "çalışma" bilgisine sahip olacaklardır.

Çoğunlukla bunun makul bir karar olduğunu söyleyebilirim. Muhtemelen:

• Bu tek bir veri türü için bayt imzasız veya en azından imzalı / imzasız alternatifler sunmuş olabilir (imzalı hale getirmek tutarlılık için iyidir, ancak ne zaman imzalı bir bayta ihtiyacınız vardır?)
• 'kısa' ile bitirdi (en son ne zaman 16 bitlik imzalı aritmetik kullandınız?)

Yine de, biraz yavaşlama ile, 32 bit'e kadar işaretsiz değerlerle ilgili işlemler çok kötü değildir ve çoğu insanın imzasız 64 bitlik veya karşılaştırmaya ihtiyacı yoktur.

Bu eski bir soru ve pat kısaca char bahsetti, ben sadece bu yolda bakacak diğerleri için bu genişletmek gerektiğini düşündüm. Java ilkel türlerine daha yakından bakalım:

byte - 8 bit işaretli tam sayı

short - 16 bit işaretli tam sayı

int - 32 bit işaretli tam sayı

long - 64 bit işaretli tam sayı

char - 16 bit karakter (işaretsiz tam sayı)

Her ne kadar chardesteklemediği unsignedaritmetik, aslında bir şekilde tedavi edilebilir unsignedtamsayı. Aritmetik işlemleri açık charbir şekilde tekrar yapmanız gerekir, ancak unsignedsayıları belirtmek için bir yol sağlar .

char a = 0;
char b = 6;
a += 1;
a = (char) (a * b);
a = (char) (a + b);
a = (char) (a - 16);
b = (char) (b % 3);
b = (char) (b / a);
//a = -1; // Generates complier error, must be cast to char
System.out.println(a); // Prints ? 
System.out.println((int) a); // Prints 65532
System.out.println((short) a); // Prints -4
short c = -4;
System.out.println((int) c); // Prints -4, notice the difference with char
a *= 2;
a -= 6;
a /= 3;
a %= 7;
a++;
a--;

Evet, imzasız tamsayılar için doğrudan destek yoktur (açıkçası, doğrudan destek olsaydı, işlemlerimin çoğunu tekrar char'a dökmek zorunda kalmazdım). Ancak, kesinlikle imzasız bir ilkel veri türü vardır. Ben de imzasız bir bayt görmek isterdim, ama bellek maliyetini iki katına ve bunun yerine char kullanmak uygun bir seçenek sanırım.

Düzenle

JDK8 ile orada yeni API'leri olan Longve Integeryardımcı yöntemleri tedavi sağlayan longve intişaretsiz değer olarak değerleri.

• compareUnsigned
• divideUnsigned
• parseUnsignedInt
• parseUnsignedLong
• remainderUnsigned
• toUnsignedLong
• toUnsignedString

Ek olarak, Guava , tamsayı türlerinde benzer şeyler yapmak için bir dizi yardımcı yöntem sağlar ve bu da tamsayılar için yerel destek eksikliğinin bıraktığı boşluğu kapatmaya yardımcı olur unsigned.

Java'nın imzasız türleri veya en az biri var: char imzasız bir kısa. Yani Gosling'in mazereti ne olursa olsun, imzasız başka türlerin bulunmaması gerçekten sadece onun cehaletidir.

Ayrıca Kısa tipler: şortlar multimedya için her zaman kullanılır. Nedeni tek bir 32-bit imzasız uzun 2 örnekleri sığdırmak ve birçok işlemi vectorized olmasıdır. 8 bit veri ve işaretsiz bayt ile aynı şey. 4 veya 8 örneği vektörleştirmek için bir kayıt defterine sığdırabilirsiniz.

En kısa sürede imzalı ve imzasız int işler karıştığında başlar bir ifadede karıştırılır ve muhtemelen olacaktır bilgileri kaybedebilirsiniz. Java'yı oturum açmış girişlerle kısıtlamak yalnızca işleri temizler. Bazen bir baytta 8. biti kaçırmama rağmen, imzalı / imzasız tüm iş için endişelenmeme gerek yok.

http://skeletoncoder.blogspot.com/2006/09/java-tutorials-why-no-unsigned.html

Bu adam diyor ki, C standardı imzasız ve imzalı ints içeren işlemleri imzasız olarak nitelendiriyor. Bu, negatif işaretli tam sayıların büyük bir imzasız int içine yuvarlanmasına neden olarak hatalara neden olabilir.

Java'nın olduğu gibi iyi olduğunu düşünüyorum, imzasız eklemek fazla kazanç olmadan karmaşık hale getirecek. Basitleştirilmiş tamsayı modelinde bile, çoğu Java programcısı temel sayısal türlerin nasıl davrandığını bilmez - sadece yanlış kavramları tutabileceğinizi görmek için Java Puzzlers kitabını okuyun .

Pratik tavsiye gelince:

• Değerleriniz biraz keyfi boyuttaysa ve uymuyorsa int, kullanın long. longKullanıma uygun olmazlarsa BigInteger.

• Daha küçük türleri yalnızca yerden tasarruf etmeniz gerektiğinde diziler için kullanın.

• Tam olarak 64/32/16/8 bite ihtiyacınız varsa, long/ int/ short/ kullanın byteve bölme, karşılaştırma, sağ kaydırma ve döküm hariç işaret biti hakkında endişelenmeyi bırakın.

"C'den Java'ya rasgele bir sayı üretecini taşıma" hakkındaki bu cevaba da bakınız .

JDK8 ile onlar için bazı destek var.

Gosling'in endişelerine rağmen Java'da imzasız türlerin tam desteğini görebiliriz.

Bu yazının çok eski olduğunu biliyorum; Ancak ilgiden dolayı, Java 8'de ve daha sonra kullanabileceğiniz inten az 0 değeri ve 2 maksimum değerine sahip işaretsiz 32 bit tam sayı, temsil etmek veri türünü ³² -1. Kullanım Integerkullanımı sınıf intişaretsiz bir tamsayı ve benzeri statik yöntemleri gibi veri türü compareUnsigned(), divideUnsigned()vb eklenen Integertamsayılar için aritmetik operasyonları desteklemek için sınıfta.

Orignal Java sürümüne yakın olacaklarını anlatan hikayeler duydum. Meşe, Java'nın öncüsüdür ve bazı spesifik belgelerde, atanmış değerlerden bahsedilmiştir. Ne yazık ki bunlar asla Java diline geçmedi. Herkesin anlayabildiği kadarıyla, muhtemelen bir zaman kısıtlaması nedeniyle, uygulanmadılar.

Bir keresinde C ++ standartlar komitesinde, Java'nın imzasız tamsayılardan kaçınmak için doğru kararı verdiğini ima eden bir C ++ kursuna katıldım, çünkü (1) imzasız tamsayılar kullanan programların çoğu imzalı tamsayılarla da yapabilir ve bu daha doğal (2) imzasız tamsayıların kullanılması, tamsayı aritmetik taşması ve imzalı ve imzasız türler arasında dönüştürme yaparken önemli bitleri kaybetme gibi sorunların hatalarını ayıklamak çok kolaydır. İşaretli tamsayıları kullanarak yanlışlıkla 0'dan 1 çıkarırsanız, programınızın daha hızlı çökmesine neden olur ve hatayı bulmayı 2 ^ 32-1'e sarar ve derleyiciler ve statik analiz araçları ve çalışma zamanı denetimleri yapmaktan daha kolay hale getirir. imzasız aritmetik kullanmayı seçtiğiniz için ne yaptığınızı bildiğinizi varsayalım. Ayrıca,

Uzun zaman önce, bellek sınırlı olduğunda ve işlemciler bir kerede 64 bit üzerinde otomatik olarak çalışmadığında, her bit çok daha fazla sayıldı, bu nedenle imzasız baytlara veya şortlara karşı imzalamak aslında çok daha önemliydi ve açık bir şekilde doğru tasarım kararıydı. Bugün sadece imzalı bir int kullanmak neredeyse tüm normal programlama vakalarında fazlasıyla yeterli ve eğer programınızın gerçekten 2 ^ 31 - 1'den büyük değerleri kullanması gerekiyorsa, genellikle uzun bir süre istersiniz. Uzun ürün kullanma bölgesine girdikten sonra, 2 ^ 63-1 pozitif tamsayılarla gerçekten başaramamanızın bir nedeni bulmak daha da zor. 128 bit işlemcilere gittiğimizde sorun daha da az olacaktır.

Sorunuz "Java neden imzalanmamış girişleri desteklemiyor?"

Ve sorunuza cevabım, Java'nın tüm ilkel türlerinin olmasını istiyor: bayt , karakter , kısa , int ve uzun , montajda olduğu gibi sırasıyla bayt , kelime , dword ve qword olarak ele alınmalı ve Java operatörleri imzalı char hariç tüm ilkel türlerinde işlemler , ancak sadece char üzerinde sadece 16 bit imzasızdır.

Yani statik yöntemler için varsayalım imzasız işlemleri de hem 32 ve 64 bit.

İmzasız işlemler için statik yöntemleri çağrılabilen son sınıfa ihtiyacınız vardır .

Bu son sınıfı oluşturabilir, istediğiniz adı çağırabilir ve statik yöntemlerini uygulayabilirsiniz.

Statik yöntemlerin nasıl uygulanacağı hakkında hiçbir fikriniz yoksa bu bağlantı size yardımcı olabilir.

Bence, Java değil C ++ diline benzer hiç o takdirde ne imzasız türlerini destekler ne de operatör aşırı yüklenmesini Java hem C ++ ve C den tamamen farklı dil olarak ele alınması gerektiğini düşünüyorum böylece,

Bu arada diller adına da tamamen farklı.

Bu yüzden Java'da C'ye benzer kod yazmanızı önermiyorum ve C ++ 'a benzer kod yazmayı hiç önermiyorum, çünkü Java'da C ++' da daha sonra ne yapmak istediğinizi yapamazsınız, yani kod hiç C ++ gibi olmaya devam etmeyecek ve benim için bu böyle kodlamak, ortadaki stili değiştirmek için kötü.

İmzalı işlemler için de statik yöntemler yazmanızı ve kullanmanızı öneririm, böylece kodda yalnızca imzalı işlemlere ihtiyacınız yoksa, işleçlerin kod karışımında ve hem imzalı hem de imzasız işlemler için statik yöntemler görmezsiniz ve yalnızca operatörleri kullanın.

Ayrıca kısa , int ve uzun ilkel türler kullanmaktan kaçınmanızı ve bunun yerine sırasıyla word , dword ve qword kullanmanızı öneririm ve operatörleri kullanmak yerine imzasız işlemler ve / veya imzalı işlemler için statik yöntemleri çağırmak üzeresiniz.

Yalnızca imzalı işlemleri yapmak ve işleçleri yalnızca kodda kullanmak üzereyseniz , bu ilkel türleri kısa , int ve uzun kullanmakta sorun yoktur .

Aslında kelime , dword ve QWORD do not dilde var, ancak her biri için yeni bir sınıf oluşturup bunu her uygulaması çok kolay olmalıdır:

Sınıf kelimesinin ilk tip tutan kısa sadece sınıf DWORD basit bir tür tutan int sadece sınıf QWORD ilkel tip tutan uzun sadece. Şimdi tüm imzasız ve imzalı yöntemler seçiminiz kadar statik olsun ya da olmasın, her sınıfta uygulayabilirsiniz, yani tüm 16 bit işlemleri hem imzasız hem de imzalı kelime sınıfında anlam adları vererek , hem 32 bit işlemleri hem de imzasız anlam isimleri vererek imzalanan dword imzasız ve üzerinde anlam isimlerini vererek imzalanmış hem sınıf ve tüm 64 bit işlemleri QWORD sınıfına.

Her yöntem için çok fazla farklı ad vermek istemiyorsanız, Java'da aşırı yüklemeyi her zaman kullanabilirsiniz, Java'nın bunu da kaldırmadığını okumak güzel !

8 bit imzalı işlemler için işleçler yerine işleçler ve hiçbir işleçleri olmayan 8 bit işaretsiz işlemler için yöntemler istiyorsanız, Bayt sınıfını oluşturabilirsiniz (ilk 'B' harfinin büyük olduğunu unutmayın, bu nedenle ilkel tip bayt ) ve bu sınıftaki yöntemleri uygular.

Değere göre geçme ve referans olarak geçme hakkında:

Yanılmıyorsam, C # 'da olduğu gibi, ilkel nesneler doğal olarak değere göre geçirilir, ancak sınıf nesneleri doğal olarak referansla geçirilir, böylece Byte , word , dword ve qword türündeki nesneler değere göre değil referansla geçirilir varsayılan olarak. Keşke Java C # gibi yapı nesneleri vardı , bu yüzden tüm Byte , kelime , dword ve qword sınıf yerine yapı olarak uygulanabilir, bu nedenle varsayılan olarak değere göre iletilir ve varsayılan olarak referans olarak değil, C #'daki herhangi bir yapı nesnesi gibi, ilkel türler gibi, varsayılan olarak referans olarak değil, değere göre iletilir, ancak Java, C # 'dan daha kötü olduğundan ve bununla başa çıkmak için, varsayılan olarak değere göre değil, yalnızca başvuru ile iletilen sınıflar ve arabirimler vardır. Bu nedenle , Bayt , kelime , dword ve qword nesnelerini, Java'daki ve C #'daki diğer herhangi bir sınıf nesnesi gibi, referansa göre değil, değere göre iletmek istiyorsanız, kopya oluşturucuyu kullanmanız gerekecektir.

Aklıma gelen tek çözüm bu. İsterdim ki o elimden sadece taşıyıcıların C # aksine hiç kelime, dword ve QWORD ancak Java ne destek typedef ne de kullanmaya ilkel türleri, typedef kullanarak C'nin typedef eşdeğerdir.

Çıktı hakkında:

Aynı bit dizisi için bunları birçok şekilde yazdırabilirsiniz: İkili olarak, ondalık olarak (C printf'de% u anlamı gibi), sekizli (C printf'de% o anlamı gibi), onaltılık olarak (gibi C printf içindeki% x'in anlamı) ve tamsayı olarak (C printf içindeki% d'nin anlamı gibi).

C printf'nin işleve parametre olarak iletilen değişkenlerin türünü bilmediğini unutmayın, bu nedenle printf her bir değişkenin türünü yalnızca işlevin ilk parametresine iletilen char * nesnesinden bilir.

Sınıfların her birinde: Bayt , sözcük , dword ve qword , yazdırma yöntemini uygulayabilir ve printf'in işlevselliğini elde edebilirsiniz, sınıfın ilkel türü imzalanmış olsa bile, aşağıdakileri içeren bazı algoritmaları izleyerek yine de imzasız olarak yazdırabilirsiniz mantıksal ve shift işlemlerinin basamakları çıktıya yazdırmasını sağlar.

Ne yazık ki size verdiğim bağlantı bu yazdırma yöntemlerinin nasıl uygulanacağını göstermiyor, ancak eminim ki bu yazdırma yöntemlerini uygulamak için gereken algoritmalar için google.

Sorunuza cevap verebileceğim ve size önerebileceğim bu kadar.

Çünkü unsignedtip saf kötülüktür.

C'nin unsigned - intürettiği gerçeği unsigneddaha da kötüdür.

İşte beni bir kereden fazla yakan sorunun bir anlık görüntüsü:

// We have odd positive number of rays, 
// consecutive ones at angle delta from each other.
assert( rays.size() > 0 && rays.size() % 2 == 1 );

// Get a set of ray at delta angle between them.
for( size_t n = 0; n < rays.size(); ++n )
{
    // Compute the angle between nth ray and the middle one.
    // The index of the middle one is (rays.size() - 1) / 2,
    // the rays are evenly spaced at angle delta, therefore
    // the magnitude of the angle between nth ray and the 
    // middle one is: 
    double angle = delta * fabs( n - (rays.size() - 1) / 2 ); 

    // Do something else ...
}

Hatayı henüz fark etmediniz mi? İtiraf ediyorum sadece hata ayıklayıcısına girdikten sonra gördüm.

Çünkü nişaretsiz tiptedir size_ttüm ifade n - (rays.size() - 1) / 2değerlendirir olarak unsigned. Bu ifadenin ortadaki ışının imzalı bir konumu olması amaçlanmıştır n: sol taraftaki ortadaki birinci ışın -1 konumuna, sağdaki birinci ışın +1 konumu vb. Olacaktır. abs değeri alarak ve deltaaçı ile çarparak ben nışın ve orta arasındaki açı elde ediyorum .

Ne yazık ki benim için yukarıdaki ifade imzasız kötüyü içeriyordu ve -1 olarak değerlendirmek yerine 2 ^ 32-1 olarak değerlendirdi. Sonraki doublehata bug kapatıldı.

unsignedAritmetiğin yanlış kullanımından kaynaklanan bir veya iki hatadan sonra , ekstra bitin ekstra soruna değip değmeyeceğini merak etmeye başlamak gerekir. unsignedİkili maskeler gibi aritmetik olmayan işlemler için hala kullanılmasına rağmen, aritmetik türlerin herhangi bir kullanımından kaçınmak için mümkün olduğu kadar çok çalışıyorum .

'C' spesifikasyonunda Java'nın pragmatik nedenlerden dolayı düştüğü ancak geliştirici talebiyle yavaş yavaş geri çekildiği (kapaklar, vb.) Birkaç mücevher var.

İlkinden bahsediyorum çünkü bu tartışma ile ilgili; işaretçi değerlerinin işaretsiz tam sayı aritmetiğine uyması. Ve bu iş parçacığı konusuyla ilgili olarak, Java'nın İmzalı dünyasında İmzasız semantiği korumanın zorluğu.

Gosling'in tasarım ekibine tavsiye etmek için bir Dennis Ritchie alter ego alacak olsaydı, Signed'in "sonsuzda sıfır" vermesini önerebilirdi, böylece tüm adres ofset talepleri önce negatif değerleri ortadan kaldırmak için CEBİRSEL HALKA BOYUTU ekleyecekti.

Bu şekilde, diziye atılan herhangi bir uzaklık hiçbir zaman bir SEGFAULT oluşturamaz. Örneğin, "kendini döndüren döngü" bağlamında imzasız davranış gerektiren çiftlerin RingArray'ı dediğim kapsüllenmiş bir sınıfta:

// ...
// Housekeeping state variable
long entrycount;     // A sequence number
int cycle;           // Number of loops cycled
int size;            // Active size of the array because size<modulus during cycle 0
int modulus;         // Maximal size of the array

// Ring state variables
private int head;   // The 'head' of the Ring
private int tail;   // The ring iterator 'cursor'
// tail may get the current cursor position
// and head gets the old tail value
// there are other semantic variations possible

// The Array state variable
double [] darray;    // The array of doubles

// somewhere in constructor
public RingArray(int modulus) {
    super();
    this.modulus = modulus;
    tail =  head =  cycle = 0;
    darray = new double[modulus];
// ...
}
// ...
double getElementAt(int offset){
    return darray[(tail+modulus+offset%modulus)%modulus];
}
//  remember, the above is treating steady-state where size==modulus
// ...

Yukarıdaki RingArray, kötü niyetli bir istekte bulunan bir kişi denemiş olsa bile, asla negatif bir dizinden 'almaz'. Unutmayın, önceki (negatif) endeks değerlerini istemek için birçok meşru istek vardır.

Not: Dış% modül, meşru talepleri referans alırken, iç% modül, bariz kötülükleri modülden daha negatif negatiflerden maskeler. Bu bir Java + 'da görünecek olsaydı .. + 9 || 8 + .. + spec, o zaman sorun gerçekten "HATA" kendi kendine dönemez bir programcı olur.

Eminim Java imzasız int 'eksikliği' yukarıdaki tek astar ile telafi edilebilir.

Not: Sadece yukarıdaki RingArray oda temizliği ile ilgili bağlam vermek için, yukarıdaki 'get' öğesi işlemiyle eşleşecek bir aday 'set' işlemi:

void addElement(long entrycount,double value){ // to be called only by the keeper of entrycount
    this.entrycount= entrycount;
    cycle = (int)entrycount/modulus;
    if(cycle==0){                       // start-up is when the ring is being populated the first time around
        size = (int)entrycount;         // during start-up, size is less than modulus so use modulo size arithmetic
        tail = (int)entrycount%size;    //  during start-up
    }
    else {
        size = modulus;
        head = tail;
        tail = (int)entrycount%modulus; //  after start-up
    }
    darray[head] = value;               //  always overwrite old tail
}

Talihsiz bir yan etki düşünebilirim. Java gömülü veritabanlarında, 32 bit kimlik alanı ile sahip olabileceğiniz kimlik sayısı 2 ^ 32 değil, 2 ^ 31'dir (~ 4 milyar değil, ~ 2 milyar).

IMHO'nun nedeni, bu hatayı uygulamak / düzeltmek için çok tembel olmaları / tembel olmalarıdır. C / C ++ programcılarının imzasız, yapı, birleşim, bit bayrağını anlamadığını önermek ... Sadece mantıklı.

Ether, bu dili gerçek bir bilgi olmadan, la C programlamaya başlayarak, bir temel / bash / java programcısıyla konuşuyordunuz ya da sadece kendi zihninizden bahsediyorsunuz. ;)

Her gün dosya veya donanımdan formatta uğraştığınızda ne düşündüklerini sormaya başlarsınız.

Burada iyi bir örnek, imzasız bir baytı kendi kendine dönen bir döngü olarak kullanmaya çalışmak olabilir. Son cümleyi anlamayanlar için, dünyada nasıl bir programcı diyorsunuz.

DC