Dlaczego Java nie obsługuje niepodpisanych ints?

Czytając między wierszami, myślę, że logika była coś takiego:

• ogólnie rzecz biorąc, projektanci Javy chcieli uprościć repertuar dostępnych typów danych
• Na co dzień uważali, że najczęstszą potrzebą są podpisane typy danych
• do implementacji pewnych algorytmów czasami potrzebna jest arytmetyka niepodpisana, ale programiści, którzy implementują takie algorytmy, również mieliby wiedzę, aby "pracować" wykonując niepodpisaną arytmetyka z podpisanymi typami danych

W większości, powiedziałbym, że to rozsądna decyzja. Możliwe, że bym:

• made byte unsigned, lub przynajmniej dostarczyły podpisane / niepodpisane alternatywy, prawdopodobnie o różnych nazwach ,dla tego jednego typu danych (robienie tego podpisanego jest dobre dla spójności, ale czy kiedykolwiek potrzebujesz podpisanego bajtu?)
• done away with 'short' (kiedy ostatnio używałeś 16-bitowej arytmetyki podpisanej?)

Mimo to, z odrobiną kludgingu, operacje na niepodpisane wartości do 32 bitów nie są złe, a większość ludzi nie potrzebuje niepodpisanego 64-bitowego podziału lub porównania.

To jest starsze pytanie i pat krótko wspomniał o char, pomyślałem tylko, że powinienem rozwinąć to dla innych, którzy będą patrzeć na to w dół drogi. Przyjrzyjmy się bliżej prymitywnym typom Javy:

byte - 8-bit signed integer

short - 16-bit signed integer

int - 32-bit signed integer

long - 64-bit signed integer

char - 16-bit character (unsigned integer)

Chociaż char nie obsługuje unsigned arytmetyka, zasadniczo może być traktowana jako unsigned liczba całkowita. Trzeba by jawnie oddać operacje arytmetyczne z powrotem do char, ale to daje sposób na określenie unsigned liczb.

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--;

Tak, nie ma bezpośredniego wsparcia dla niepodpisanych liczb całkowitych(oczywiście, nie musiałbym wyrzucać większości moich operacji z powrotem do char, gdyby istniało bezpośrednie wsparcie). Jednak z pewnością istnieje niepodpisany prymitywny typ danych. Też chciałbym zobaczyć bajt niepodpisany, ale Odgadnij podwojenie kosztów pamięci i zamiast tego użyj char jest realną opcją.

Edit

Z JDK8 są nowe Api dla Long oraz Integer które zapewniają metody pomocnicze przy traktowaniu wartości long i int jako wartości niepodpisane.

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

Dodatkowo, guawa zapewnia szereg metod pomocniczych aby zrobić podobne rzeczy dla typów liczb całkowitych, co pomaga zamknąć lukę pozostawioną przez brak natywnego wsparcia dla unsigned liczb całkowitych.

Java ma niepodpisane typy lub przynajmniej jeden: char jest niepodpisanym skrótem. Więc jakąkolwiek wymówkę wyrzuca Gosling, to tylko jego ignorancja, dlaczego nie ma innych niepodpisanych typów.

Również krótkie typy: szorty są używane przez cały czas do multimediów. Powodem jest to, że możesz zmieścić 2 próbki W Jednym 32-bitowym unsigned long I wektoryzować wiele operacji. To samo dotyczy danych 8-bitowych i bajtów niepodpisanych. Możesz zmieścić 4 lub 8 próbek w Rejestrze do wektoryzacji.

Gdy tylko signed i unsigned int zostaną zmieszane w wyrażeniu, zaczyna się robić bałagan i prawdopodobnie utracisz informacje. Ograniczenie Javy do podpisanych ints tylko naprawdę oczyszcza wszystko. Cieszę się, że nie muszę się martwić o cały podpisany/niepodpisany biznes, choć czasami brakuje mi 8 bitu w bajcie.

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

Ten facet mówi, ponieważ standard C definiuje operacje z udziałem unsigned i signed int, które mają być traktowane jako unsigned. Może to spowodować, że ujemne liczby całkowite podpisane przetaczają się do dużej niepodpisanej liczby całkowitej, potencjalnie powodując błędy.

Myślę, że Java jest w porządku, dodanie unsigned skomplikowałoby to bez większego zysku. Nawet przy uproszczonym modelu liczbowym, większość programistów Javy nie wie, jak zachowują się podstawowe typy liczbowe - wystarczy przeczytać książkę Java Puzzlers , aby zobaczyć, jakie błędne przekonania możesz trzymać.

Co do praktycznych porad:

• Jeśli twoje wartości są nieco dowolne i nie pasują do int, użyj long. Jeśli nie pasują do long Użyj BigInteger.

• Użycie mniejsze typy tylko dla tablic, gdy trzeba zaoszczędzić miejsce.

• Jeśli potrzebujesz dokładnie 64/32/16/8 bitów, użyj long/int/short/byte i przestań się martwić o znak, z wyjątkiem podziału, porównania, prawej zmiany i rzutu.

Patrz również ta odpowiedź na temat "przenoszenie generatora liczb losowych z języka C na język Java".

Wiem, że ten post jest zbyt stary; jednak dla Twojego zainteresowania, w Javie 8 i późniejszych, możesz użyć typu danych int do reprezentowania niepodpisanej 32-bitowej liczby całkowitej, która ma minimalną wartość 0 i maksymalną wartość 2³²-1. Użyj klasy Integer, Aby użyć typu danych int jako niepodpisanej liczby całkowitej i metod statycznych, takich jak compareUnsigned(), divideUnsigned() itd. zostały dodane do klasy Integer w celu obsługi operacji arytmetycznych dla niepodpisanych liczb całkowitych.

Z JDK8 ma dla nich pewne wsparcie.

Mimo obaw Goslinga możemy jeszcze zobaczyć pełne wsparcie dla niepodpisanych typów w Javie.

Słyszałem historie, że miały być dołączone blisko wydania oryginalnej Javy. Dąb był prekursorem Jawy, a w niektórych dokumentach spec wspomniano o wartościach użytkowych. Niestety te nigdy nie dotarły do języka Java. O ile ktoś był w stanie dowiedzieć się, że po prostu nie został wdrożony, prawdopodobnie z powodu ograniczenia czasowego.

Kiedyś brałem udział w kursie C++ z kimś z Komitetu Standardów C++, który zasugerował, że Java podjęła właściwą decyzję, aby uniknąć niepodpisanych liczb całkowitych, ponieważ (1) większość programów używających niepodpisanych liczb całkowitych może robić tak samo dobrze z podpisanymi liczbami całkowitymi, co jest bardziej naturalne pod względem sposobu myślenia ludzi, oraz (2) używanie niepodpisanych liczb całkowitych powoduje wiele łatwych do utworzenia, ale trudnych do debugowania problemów, takich jak przepełnienie arytmetyki całkowitej i utrata znaczących bitów podczas konwersji pomiędzy podpisanymi i podpisanymi niepodpisane typy. Jeśli przez pomyłkę odjmiesz 1 od 0 używając podpisanych liczb całkowitych, często szybciej spowoduje to awarię programu i ułatwi znalezienie błędu niż Jeśli zawija się do 2^32-1, A Kompilatory, narzędzia analizy statycznej i kontrole wykonawcze muszą zakładać, że wiesz, co robisz, ponieważ zdecydowałeś się użyć arytmetyki niepodpisanej. Ponadto liczby ujemne, takie jak -1, mogą często reprezentować coś użytecznego, na przykład pole ignorowane/defaulted / unset, podczas gdy gdybyś używał unsigned, miałbyś aby zarezerwować specjalną wartość, taką jak 2^32-1 lub coś podobnego.

Dawno temu, kiedy pamięć była ograniczona, a procesory nie działały automatycznie NA 64 bitach na raz, każdy bit liczył o wiele więcej, więc posiadanie podpisanych i niepodpisanych bajtów lub skrótów miało znaczenie o wiele częściej i było oczywiście właściwą decyzją projektową. Dzisiaj samo użycie podpisanego int jest więcej niż wystarczające w prawie wszystkich zwykłych przypadkach programowania, a jeśli twój program naprawdę potrzebuje użyć wartości większych niż 2^31-1, możesz często po prostu chcą długo i tak. Gdy już jesteś na terytorium używania longów, jeszcze trudniej jest wymyślić powód, dla którego naprawdę nie możesz poradzić sobie z 2^63 - 1 dodatnimi liczbami całkowitymi. Ilekroć przejdziemy do procesorów 128-bitowych, będzie to jeszcze mniej problematyczne.

Twoje pytanie brzmi "dlaczego Java nie obsługuje unsigned ints"?

A moja odpowiedź na twoje pytanie brzmi, że Java chce, aby wszystkie jej prymitywne typy: bajt, char, krótkie, int i long należy traktować jako bajt, słowo, dword i qword , odpowiednio, podobnie jak w assembly, a operatory Javy są operacjami signed na wszystkich jego prymitywnych typach z wyjątkiem char , ale tylko na char są niepodpisane tylko 16-bitowe.

Więc metody statyczne przypuszczają, że operacje unsigned również zarówno dla 32, jak i 64 bitów.

Potrzebna jest klasa końcowa, której statyczne metody mogą być wywoływane dla operacji unsigned .

Możesz utworzyć tę końcową klasę, nazwać ją dowolną nazwą i zaimplementować jej statyczne metody.

Jeśli nie masz pojęcia jak zaimplementować statyczne metody to ten link może pomóc ty.

Moim zdaniem Java jest NIE podobna do C++ w ogóle , Jeśli ani nie obsługuje typów niepodpisanych ani przeciążania operatorów, więc myślę, że Java powinna być traktowana jako zupełnie inny język zarówno od C++, jak i od C.

Jest też zupełnie inaczej w nazwie języków przy okazji.

Więc nie polecam w Javie wpisywania kodu podobnego do C i w ogóle nie polecam wpisywania kodu podobnego do c++, bo wtedy w Javie nie będziesz w stanie robić tego co chcesz dalej w C++, tzn. kod nie będzie w ogóle taki jak C++ i dla mnie źle jest z takim kodem, żeby zmienić styl w środku.

Zalecam pisanie i używanie metod statycznych również dla operacji podpisanych, więc nie widzisz w kodzie mieszanki operatorów i metod statycznych zarówno dla operacji podpisanych jak i niepodpisanych, chyba że potrzebujesz tylko operacji podpisanych w kodzie, a używanie tylko operatorów jest w porządku.

Także Ja zaleca się unikać używania krótkich, Int i long oraz używać wyrazu, zamiast tego dword i qword , a Ty chcesz wywołać statyczne metody dla operacji niepodpisanych i/lub podpisanych zamiast używać operatorów.

Jeśli masz zamiar wykonywać tylko operacje podpisane i używać operatorów tylko w kodzie, to jest w porządku używać tych prymitywnych typów krótkie, int oraz long .

Właściwie słowo, dword and qword do n ' T exist in the language, but you can create new class for each and the implementation of each should be very easy:

Klasa word przechowuje tylko Typ prymitywny short, klasa dword przechowuje tylko Typ prymitywny int, A klasa qword przechowuje tylko Typ prymitywny long. Teraz wszystkie niepodpisane i podpisane metody jako statyczne lub nie jako twój wybór, możesz zaimplementować w każdej klasie, tj. wszystkie 16-bitowe operacje zarówno niepodpisane, jak i podpisane przez podanie nazw znaczeniowych na klasie word, wszystkie 32-bitowe operacje zarówno niepodpisane, jak i podpisane przez podanie nazw znaczeniowych na klasie dword oraz wszystkie 64-bitowe operacje zarówno niepodpisane, jak i podpisane przez podanie nazw znaczeniowych na klasie qword.

Jeśli nie lubisz podawać zbyt wielu różnych nazw dla każdej metody, zawsze możesz użyć przeciążenia w Java, dobrze przeczytać, że Java nie NIE to też usunąć!

Jeśli wolisz metody zamiast operatorów dla 8-bitowych operacji podpisanych i metody dla 8-bitowych operacji niepodpisanych, które w ogóle nie mają operatorów, możesz utworzyć klasę Byte (zauważ, że pierwsza litera 'B' jest wielka, więc nie jest to prymitywny typ byte ) i zaimplementować metody w tej klasie.

O przekazywaniu przez wartość i przekazywaniu przez referencję:

Jeśli się nie mylę, jak w C#, obiekty prymitywne są przekazywane przez wartość w sposób naturalny, ale obiekty klas są przekazywane przez odniesienie w sposób naturalny, co oznacza, że obiekty typu Byte, słowo, dword i qword będą przekazywane przez odniesienie, a nie przez wartość domyślnie. Szkoda, że Java nie ma struct obiektów tak jak C # ma, więc wszystkie bajty, słowo, dword i qword mogą być zaimplementowane jako struct zamiast class, więc domyślnie były przekazywane przez value I not by reference domyślnie, jak każdy obiekt struct w C#, podobnie jak typy prymitywne, są przekazywane przez value, a nie przez reference domyślnie, ale ponieważ Java jest gorsza od C# i mamy do czynienia z tym, wtedy są tylko klasy i interfejsy, które są przekazywane przez reference, a nie przez value domyślnie. Więc jeśli chcesz przekazać Bajt, słowo, dword i QWord obiekty według wartości, a nie przez odniesienie, jak każdy inny obiekt klasy w Javie, a także w C#, będziesz musiał po prostu użyć konstruktora kopiującego i to wszystko.

To jedyne rozwiązanie, o którym mogę myśleć. Po prostu chciałbym móc po prostu typedef prymitywnych typów do Worda, dword i qword, ale Java ani nie obsługuje typedef ani nie używa w ogóle, w przeciwieństwie do C#, który obsługuje używając, który jest odpowiednikiem C typedef.

About output:

Dla tego samego ciągu bitów , można je wydrukować na wiele sposobów: jako binarne, jako dziesiętne (jak znaczenie %u w C printf), jako ósemkowy (jak znaczenie %o W C printf), jako szesnastkowy (jak znaczenie %X w C printf) i jako liczba całkowita (jak znaczenie %d w C printf).

Należy zauważyć, że C printf nie zna typu zmiennych przekazywanych jako parametry do funkcji, więc printf zna Typ każdej zmiennej tylko z obiektu char * przekazanego do pierwszego parametru funkcji.

Więc w każdej z klas: Bajt, słowo, dword oraz qword , możesz zaimplementować metodę drukowania i uzyskać funkcjonalność printf, nawet jeśli prymitywny typ klasy jest podpisany, nadal możesz wydrukować go jako niepodpisany, postępując zgodnie z pewnym algorytmem obejmującym operacje logiczne i shift, aby uzyskać cyfry do wydrukowania na wyjściu.

Niestety link, który ci dałem nie pokazuje, jak zaimplementować te metody drukowania, ale jestem pewien, że możesz wyszukać algorytmy, których potrzebujesz, aby zaimplementować te metody drukowania.

That ' s all I can odpowiedz na pytanie i zaproponuj.

Ponieważ unsigned typ jest czystym złem.

Fakt, że w C unsigned - int produkuje unsigned jest jeszcze bardziej zły.

Oto migawka problemu, który spalił mnie więcej niż raz:

// 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 ...
}

Zauważyłeś już błąd? Przyznaję, że widziałem to dopiero po wejściu z debuggerem.

Ponieważ n jest typu unsigned size_t całe wyrażenie n - (rays.size() - 1) / 2 jest ewaluowane jako unsigned. Wyrażenie to ma być podpisane pozycja npromienia z środkowy: pierwszy promień ze środkowego z lewej strony miałby pozycję -1, pierwszy z prawej miałby pozycję +1, itd. Po pobraniu wartości abs i pomnożeniu przez kąt delta otrzymałbym kąt między promieniem n A promieniem środkowym.

Niestety dla mnie powyższe wyrażenie zawierało zło niepodpisane i zamiast Oceniać do, powiedzmy, -1, oceniało do 2^32-1. Kolejna konwersja na double przypieczętowała błąd.

Po Bugu lub dwóch spowodowanych przez nadużywanie unsigned arytmetyki trzeba zacząć zastanawiać się, czy dodatkowy bit jest wart dodatkowego kłopotu. Staram się, na ile to możliwe, unikać używania typów unsigned w arytmetyce, chociaż nadal używam ich do operacji nie arytmetycznych, takich jak maski binarne.

Jest kilka klejnotów w specyfikacji "C", które Java spadła z pragmatycznych powodów, ale które powoli powracają wraz z zapotrzebowaniem deweloperów (zamknięcia itp.).

Wspominam o pierwszym, ponieważ jest to związane z tą dyskusją; przestrzeganie wartości wskaźnika do unsigned integer arytmetyki. A w odniesieniu do tego tematu wątku, trudność utrzymania Niepodpisanej semantyki w podpisanym świecie Javy.

Myślę, że gdyby ktoś miał doradzić Alter ego Dennisa Ritchiego Zespół projektowy Goslinga sugerowałby nadanie Signed ' s "zero w nieskończoności", aby wszystkie żądania przesunięcia adresu najpierw dodały swój algebraiczny rozmiar pierścienia, aby wyeliminować wartości ujemne.

W ten sposób każde przesunięcie rzucone na tablicę nie może wygenerować SEGFAULT. Na przykład w zamkniętej klasie, którą nazywam ringarray sobowtórów, które wymagają niepodpisanego zachowania - w kontekście "samoobrotowej pętli": {]}

// ...
// 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
// ...

Powyższy RingArray nigdy nie "dostanie się" z ujemnego indeksu, nawet jeśli złośliwy żądający próbował. Pamiętaj, że istnieje również wiele uzasadnionych próśb o wcześniejsze (ujemne) wartości indeksu.

NB: zewnętrzny moduł % odsyła uzasadnione żądania, podczas gdy wewnętrzny moduł %maskuje rażącą złośliwość z negatywów bardziej ujemnych niż-Moduł. Gdyby to kiedykolwiek pojawiło się w Javie +..+9 || 8+..+ spec, wtedy problem rzeczywiście stałby się " programistą, który nie może "samodzielnie obracać się"".

Jestem pewien, że tak zwana Java unsigned int "niedobór" można uzupełnić powyższą jednowarstwową.

PS: aby dać kontekst powyższej operacji ringarray, oto kandydująca operacja 'set' pasująca do powyższej operacji' get ' elementu:

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
}

Przychodzi mi do głowy jeden niefortunny efekt uboczny. W wbudowanych bazach danych java liczba identyfikatorów, które możesz mieć z polem 32bit id, wynosi 2^31, a nie 2^32 (~2 miliard, nie ~4 miliard).

Powodem IMHO jest to, że są/byli zbyt leniwi, aby wdrożyć / skorygować ten błąd. Sugerując, że programiści C / C++ nie rozumieją unsigned, structure, union, bit flag... To niedorzeczne.

Eter rozmawiałeś z programistą Bash/java na skraju rozpoczęcia programowania a la C, bez żadnej prawdziwej znajomości tego języka lub po prostu mówisz z własnego umysłu. ;)

Gdy codziennie zajmujesz się formatem z pliku lub sprzętu, zaczynasz żeby zapytać, co oni sobie myśleli.

Dobrym przykładem jest próba użycia bajtu niepodpisanego jako samoobrotowej pętli. Dla tych z Was, którzy nie rozumieją ostatniego zdania, jak u licha nazywacie siebie programistą.

DC