Чому Java не підтримує неподписані вставки?

Чому Java не включає підтримку непідписаних цілих чисел?

Мені це здається дивним упущенням, враховуючи те, що вони дозволяють писати код, який менш імовірно створює переповнення на несподівано великий вхід.

Крім того, використання непідписаних цілих чисел може бути формою самодокументації, оскільки вони вказують на те, що значення, яке повинен був утримувати непідписаний int, ніколи не повинно бути негативним.

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

Який мінус включати їх?

Це з інтерв'ю з Гослінг та іншими , про простоту:

Гослінг: Для мене як мовного дизайнера, який я насправді не вважаю таким, як сьогодні, я міг би сподіватися на те, що "простий" сенс закінчився. Це визначення говорить, що, наприклад, Java не є - і насправді багато цих мов закінчуються безліччю кутових справ, речей, які ніхто насправді не розуміє. Випробуйте будь-якого розробника C щодо неподписаного, і досить скоро ви дізнаєтесь, що майже жоден розробник C насправді не розуміє, що відбувається з непідписаними, що таке арифметика без підпису. Такі речі зробили C складним. Мовна частина Java - я думаю, досить проста. Бібліотеки, які ви повинні шукати.

Читаючи між рядків, я думаю, що логіка була приблизно такою:

• загалом дизайнери Java хотіли спростити репертуар наявних типів даних
• для повсякденних цілей вони вважали, що найчастіше потрібні підписані типи даних
• для реалізації певних алгоритмів іноді потрібна непідписана арифметика, але такий тип програмістів, які реалізовували б такі алгоритми, також матимуть знання "обійтися", виконуючи непідписану арифметику із підписаними типами даних

Здебільшого, я б сказав, це було розумне рішення. Можливо, я мав би:

• зробив байт без підпису або принаймні надав підписані / непідписані альтернативи, можливо, з різними іменами, для цього одного типу даних (зробити його підписаним добре для узгодженості, але коли вам коли-небудь потрібен підписаний байт?)
• покінчено з "коротким" (коли ти востаннє використовував 16-бітну арифметику з підписами?)

Тим не менш, дещо хитро, операції з непідписаними значеннями до 32 біт не надто погані, і більшість людей не потребують 64-бітового поділу або порівняння без підпису.

Це давнє запитання, і Пат коротко згадував про чар, я просто думав, що слід розширити це для інших, хто буде дивитись на це вниз. Давайте детальніше розглянемо примітивні типи Java:

byte - 8-бітове підписане ціле число

short - 16-бітове підписане ціле число

int - ціле число з 32-розрядним підписом

long - 64-бітове підписане ціле число

char - 16-розрядний символ (непідписане ціле число)

Хоча charне підтримує unsignedарифметику, вона по суті може трактуватися як unsignedціле число. Вам доведеться явно повернути арифметичні операції назад char, але це дає вам спосіб вказати unsignedчисла.

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

Так, немає прямої підтримки непідписаних цілих чисел (очевидно, я б не мав переводити більшість моїх операцій назад у char, якби була пряма підтримка). Однак, безумовно, існує неподписаний примітивний тип даних. Я також хотів би бачити неподписаний байт, але, мабуть, подвоєння вартості пам'яті і замість цього використання char є можливим варіантом.

Редагувати

З JDK8 є новий API - інтерфейси для Longі Integerякі забезпечують допоміжні методи при лікуванні longі intзначення як беззнакові значення.

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

Крім того, Guava пропонує ряд допоміжних методів для подібних дій для цілих типів, що допомагає усунути прогалину, залишену через відсутність вбудованої підтримки unsignedцілих чисел.

У Java є неподписані типи або хоча б один: char - це непідписаний шорт. Тож будь-яке виправдання, яке підкидає Гослінг, це насправді лише його незнання, чому немає інших неподписаних типів.

Також короткі типи: шорти весь час використовуються для мультимедіа. Причина полягає в тому, що ви можете помістити 2 зразки в один 32-бітний безпідписаний довгий і векторизувати багато операцій. Те ж саме з 8-бітовими даними та неподписаним байтом. Ви можете помістити 4 або 8 зразків у реєстр для векторизації.

Як тільки підписані та непідписані вставки змішуються в виразі, речі починають бруднитися, і ви, ймовірно , втратите інформацію. Обмеження Java лише підписаними вставками дійсно очищає речі. Я радий, що мені не потрібно турбуватися про весь підписаний / непідписаний бізнес, хоча я іноді пропускаю 8-й біт у байті.

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

Цей хлопець каже, тому що стандарт C визначає операції, що включають безпідписані та підписані входи, які слід трактувати як неподписані. Це може призвести до негативного підписання цілих чисел у великий неподписаний int, що може призвести до помилок.

Я думаю, що Java гарна, як є, додавання неподписаного ускладнить це без особливих вигод. Навіть із спрощеною цілочисельною моделлю більшість Java-програмістів не знають, як поводяться основні числові типи - просто прочитайте книгу Java Puzzlers, щоб побачити, які неправильні уявлення ви можете мати.

Що стосується практичних порад:

• Якщо ваші значення мають дещо довільний розмір і не вміщуються int, використовуйте long. Якщо вони не підходять для longвикористання BigInteger.

• Використовуйте менші типи лише для масивів, коли вам потрібно заощадити місце.

• Якщо вам потрібно точно 64/32/16/8 біт, скористайтеся long/ int/ short/ byteі перестаньте турбуватися про біт знаків, за винятком поділу, порівняння, зрушення праворуч та кастингу.

Дивись також цю відповідь про "перенесення генератора випадкових чисел з C на Java".

З JDK8 він має деяку підтримку для них.

Ми все ще можемо побачити повну підтримку неподписаних типів на Java, незважаючи на занепокоєння Gosling.

Я знаю, що ця публікація занадто стара; однак для вашого інтересу в Java 8 та пізніших версіях ви можете використовувати intтип даних для представлення непідписаного 32-бітного цілого числа, яке має мінімальне значення 0 та максимальне значення 2 ³² −1. Використовуйте Integerклас для використання intтипу даних у вигляді цілого цілого числа, не підписаного, а статичні методи, наприклад compareUnsigned(), divideUnsigned()тощо, додані до Integerкласу для підтримки арифметичних операцій для непідписаних цілих чисел.

Я чув історії про те, що їх потрібно було включити близько до оригінального випуску Java. Дуб був попередником Яви, і в деяких специфічних документах згадувалося про призначені значення. На жаль, вони ніколи не перетворилися на мову Java. Наскільки хтось зміг зрозуміти, що вони просто не були реалізовані, ймовірно, через часові обмеження.

Одного разу я взяв курс C ++ з ким-небудь з комітету зі стандартів C ++, який натякав на те, що Java прийняла правильне рішення, щоб уникнути наявності непідписаних цілих чисел, оскільки (1) більшість програм, які використовують непідписані цілі числа, можуть робити так само добре з підписаними цілими числами, і це більш природно в Умови, як люди думають, і (2) використання непідписаних цілих чисел призводить до того, що дуже легко створити, але важко налагодити такі проблеми, як цілі арифметичні переповнення та втрата значних бітів при перетворенні між підписаними та неподписаними типами. Якщо ви помилково віднімете 1 з 0 за допомогою підписаних цілих чисел, це часто швидше призводить до краху вашої програми та полегшує пошук помилки, ніж якщо вона обертається до 2 ^ 32 - 1, а компілятори та інструменти статичного аналізу та перевірки часу виконання повинні припустимо, ви знаєте, що ви робите, оскільки ви вирішили використовувати арифметику без підпису. Також,

Давно, коли пам’ять була обмежена і процесори не працювали автоматично на 64 бітах одночасно, кожен біт нараховував набагато більше, тому підписання проти неподписаних байтів або шортів насправді мало значення набагато частіше і, очевидно, було правильним дизайнерським рішенням. Сьогодні просто використання підписаного int більш ніж достатньо майже у всіх звичайних випадках програмування, і якщо вашій програмі дійсно потрібно використовувати значення, що перевищують 2 ^ 31 - 1, то все одно просто потрібно довго. Після того, як ви потрапите на територію використання лонг, ще складніше придумати причину, чому ви дійсно не можете обійтись з 2 ^ 63 - 1 натуральними числами. Кожного разу, коли ми переходимо до 128-бітових процесорів, це буде ще меншою проблемою.

Ваше питання "Чому Java не підтримує неподписані вставки"?

І моя відповідь на ваше запитання полягає в тому, що Java хоче, щоб усі її примітивні типи: байт , char , короткий , int і long слід розглядати як байт , слово , dword і qword відповідно, точно так само, як у зборі, і оператори Java підписуються Операції з усіма його примітивними типами, крім char , але тільки на char вони не підписані лише 16 біт.

Таким чином, статичні методи можуть вважати операції без підпису і для 32, і для 64 біт.

Вам потрібен остаточний клас, статичні методи якого можна викликати для непідписаного операцій.

Ви можете створити цей остаточний клас, назвати його будь-яким ім'ям і реалізувати його статичними методами.

Якщо ви не маєте уявлення про те, як реалізувати статичні методи, тоді це посилання може вам допомогти.

На мій погляд, Java це НЕ схоже на C ++ взагалі , якщо він ні не підтримує беззнакові типи , ні перевантаження операторів, тому я думаю , що Java слід розглядати як абсолютно іншу мову як від C ++ і від C.

Це, до речі, також зовсім інше в назві мов.

Тому я не рекомендую в Java вводити код, подібний до C, і взагалі не рекомендую вводити код, схожий на C ++, тому що тоді на Java ви не зможете робити те, що хочете зробити далі в C ++, тобто код не буде продовжувати бути C ++, як взагалі, і для мене це погано кодувати таким чином, щоб змінити стиль посередині.

Я рекомендую писати та використовувати статичні методи також для підписаних операцій, так що ви не бачите в кодовій суміші операторів і статичних методів як для підписаних, так і для непідписаних операцій, якщо вам не потрібні лише підписані операції в коді, і це добре використовувати лише операторів.

Також я рекомендую уникати використання коротких , int та довгих примітивних типів, а замість цього використовувати слово word , dword та qword , і ви збираєтесь викликати статичні методи для непідписаних операцій та / або підписаних операцій замість використання операторів.

Якщо ви збираєтеся робити лише підписані операції та використовувати оператори лише в коді, тоді це нормально, щоб використовувати ці примітивні типи короткий , int та long .

На насправді слово , DWord і QWORD робити НЕ існує в мові, але ви можете створити новий клас для всіх і реалізація кожного має бути дуже легко:

Клас слово має примітивний тип короткий тільки клас DWORD має примітивний тип Int тільки і клас QWORD тримає примітивний тип довго тільки. Тепер усі непідписані та підписані методи як статичні чи не як ваш вибір, ви можете реалізувати у кожному класі, тобто всі 16-бітові операції як без підпису, так і підписані, надаючи значущі імена для класу word , всі 32-бітні операції як без підпису, так і підписується шляхом додавання значень імен класу dword та всіх 64-бітових операцій як без підпису, так і підписується шляхом надання значень імен класу qword .

Якщо вам не подобається давати занадто багато різних імен для кожного методу, ви завжди можете використовувати перевантаження в Java, добре читати, що Java теж не видаляла цього!

Якщо ви хочете скористатися методами, а не операторами для 8-бітових підписаних операцій та методів для 8-бітових безпідписаних операцій, у яких взагалі немає операторів, тоді ви можете створити клас Byte (зауважте, що перша літера "B" є великою літерою, тому це не примітивний тип байта ) та реалізувати методи цього класу.

Про проходження за значенням та проходження за посиланням:

Якщо я не помиляюся, як, наприклад, у C #, примітивні об'єкти передаються за значенням природним чином, але об'єкти класу передаються посиланням природним чином, так що це означає, що об'єкти типу Byte , word , dword та qword передаватимуться посиланням, а не значенням за замовчуванням. Я хочу Java мала STRUCT об'єктів в C # є, так що все Byte , слово , подвійне слово і QWORD можуть бути реалізовані як структура замість класу, тому за замовчуванням вони передавались за значенням, а не за посиланням за замовчуванням, як і будь-який структурний об'єкт у C #, як і примітивні типи, передаються за значенням, а не за посиланням за замовчуванням, а тому, що Java гірша за C # і ми маємо щоб вирішити це, тоді є лише класи та інтерфейси, які передаються посиланням, а не значенням за замовчуванням. Отже, якщо ви хочете передати об'єкти байт , слово , dword та qword за значенням, а не за посиланням, як і будь-який інший об’єкт класу на Java, а також на C #, вам доведеться просто використовувати конструктор копій, і все.

Це єдине рішення, про яке я можу подумати. Я просто хочу, щоб я міг просто вводитипримітивні типи до слова, dword та qword, але Java ні підтримує typedef, ні використовує зовсім, на відміну від C #, який підтримує використання , що еквівалентно typedef C.

Про вихід:

Для однієї і тієї ж послідовності бітів ви можете їх друкувати різними способами: як двійкові, як десяткові (як значення% u в C printf), як восьмеричні (як значення% o в C printf), так і шістнадцяткові (як значення% x в C printf) і як ціле число (як значення значення% d у printf).

Зауважте, що C printf не знає тип змінних, що передаються як параметри функції, тому printf знає тип кожної змінної лише з об'єкта char *, переданого першому параметру функції.

Отже, у кожному з класів: байт , слово , dword та qword , ви можете реалізувати метод друку та отримати функціональність printf, навіть незважаючи на те, що примітивний тип класу підписаний, ви все одно можете роздрукувати його як без підпису, дотримуючись деякий алгоритм, що включає логічні та зсувні операції, щоб отримати цифри для друку на вихід.

На жаль, посилання, яке я вам дав, не показує, як реалізувати ці методи друку, але я впевнений, що ви можете шукати в Google за алгоритмами, необхідними для реалізації цих методів друку.

Це все, що я можу відповісти на ваше запитання та запропонувати вам.

Тому що unsignedтип - це чисте зло.

Те, що в С unsigned - intвиробляє unsigned, ще більше зла.

Ось знімок проблеми, яка не раз спалювала мене:

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

Ви ще помітили помилку? Зізнаюся, я бачив це лише після того, як вступив з налагоджувачем.

Оскільки nнепідписаний тип, size_tвесь вираз n - (rays.size() - 1) / 2оцінюється як unsigned. Цей вираз призначений як підписане положення nпроменя першого від середнього: 1-й промінь із середнього з лівого боку мав би позицію -1, 1-й з правого - позицію +1 тощо. Після приймаючи значення abs і помножуючи на deltaкут, я отримав би кут між nпроменем та середнім.

На жаль, для мене вищевказаний вираз містив непідписане зло і замість того, щоб оцінювати до, скажімо, -1, він оцінював до 2 ^ 32-1. Подальше перетворення на doubleгерметичну помилку.

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

У специфікації "C" є кілька дорогоцінних каменів, які Java викинула з прагматичних причин, але вони поволі відступають із попитом розробників (закриття тощо).

Я згадую перший, тому що він пов'язаний з цією дискусією; прихильність значень вказівника до непідписаної цілочисельної арифметики. І стосовно цієї теми теми, складність у підтримці непідписаної семантики у світі підписів Java.

Я б здогадувався, якби отримати Денніс Річі альтер-его, щоб порадити команду дизайнерів Gosling, він запропонував би дати Signed "нуль у нескінченності", щоб усі запити на зміщення адреси спочатку додавали свій РАЗМЕР ALGEBRAIC RING для усунення негативних значень.

Таким чином, будь-яке зміщення, кинуте на масив, ніколи не може генерувати SEGFAULT. Наприклад, в інкапсульованому класі, який я називаю RingArray з пар, який потребує непідписаної поведінки, в контексті "самообертового циклу":

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

Вищенаведений RingArray ніколи не буде «отримувати» від негативного індексу, навіть якби зловмисний запитувач намагався цього зробити. Пам'ятайте, також існує багато законних запитів на запит попередніх (негативних) значень індексу.

Примітка: Зовнішній модуль% де-посилає законні запити, тоді як внутрішній модуль% маскує кричущу шкідливість з негативів, більше негативних, ніж -модулів. Якби це колись з'являлося в Java + .. + 9 || 8 + .. + специфікація, тоді проблема справді перетвориться на "програміста, який не може" самостійно обертатись "НЕПРАВНО".

Я впевнений, що так званий Java непідписаний int 'дефіцит' може бути компенсований за допомогою вищевказаного одного вкладиша.

PS: Просто, щоб дати контекст вищевказаному господарству RingArray, ось операція "встановити" кандидата, щоб відповідати вищевказаній операції "get":

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
}

Я можу придумати один нещасний побічний ефект. У базі даних, вбудованих в Java, кількість ідентифікаторів, які ви можете мати із 32-бітовим полем ідентифікатора, становить 2 ^ 31, а не 2 ^ 32 (~ 2 млрд, не ~ 4 млрд).

Причина ІМХО полягає в тому, що вони / були ліниві, щоб реалізувати / виправити цю помилку. Припустити, що програмісти C / C ++ не розуміють безпідписаного, структури, об'єднання, бітового прапора ... Це просто безглуздо.

Ефір, з яким ви розмовляли з базовим / bash / java-програмістом на межі початку програмування a la C, не маючи реальних знань на цій мові або ви просто розмовляєте не з власного розуму. ;)

коли ти щодня розбираєшся у форматі або з файлу, або з обладнання, ти починаєш ставити під сумнів, про що вони думали?

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

Постійного струму