Які найкращі практики щодо непідписаних літер?

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

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

Редагувати: З цього питання я також помічав, що в C повернення негативних значень для помилок є звичайним явищем, а не викиданням винятків, як у C ++.

Чи є щось вирішальне, що я не помічаю?

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

Я вважаю, що це головна причина, чому Java опустила неподписані типи int.

Я думаю, що у Майкла є вагомий момент, але ІМО, чому всі користуються int весь час (особливо в for (int i = 0; i < max, i++), полягає в тому, що ми дізналися це саме так. Коли кожен приклад в « як навчитися програмувати » книга використовує intв forциклі, далеко не всі коли - небудь питання такої практики.

Інша причина - intце на 25% коротше uint, і ми всі ліниві ... ;-)

Кодування інформації про діапазон у типи - це хороша річ. Він застосовує розумні числа під час компіляції.

Багато архітектури , здається, мають спеціалізовані інструкції по роботі з int-> floatперетворення. Перетворення з unsignedможе бути повільніше (крихітний біт) .

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

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

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

Я використовую unsigned intв C ++ для індексів масиву, в основному, і для будь-якого лічильника, який починається з 0. Я думаю, що добре сказати прямо "ця змінна не може бути негативною".

Вам слід потурбуватися про це, коли ви маєте справу з цілим числом, яке може насправді наближатись або перевищувати межі підписаного int. Оскільки позитивний максимум 32-бітного цілого числа становить 2,147,483,647, то слід використовувати непідписаний int, якщо ви знаєте, що це: a) ніколи не буде від'ємним і b) може досягти 2,147,483,648. У більшості випадків, включаючи ключі бази даних та лічильники, я навіть ніколи не підходжу до подібних чисел, тому не турбуюся про те, щоб переживати, чи використовується бітовий знак для числового значення чи для позначення знаку.

Я б сказав: використовуйте Int, якщо ви не знаєте, що вам потрібен неподписаний int.

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

Якщо ви коли-небудь робите будь-яке програмування з високою надійністю в Ada, ви навіть використовуєте різні типи для таких змінних, як відстань у футах проти відстані в метрах, і компілятор позначає це, якщо випадково призначите одну іншу. Це ідеально підходить для програмування керованої ракети, але перевищення (призначене каламбур), якщо ви перевіряєте веб-форму. Не обов'язково нічого поганого в будь-якому випадку, якщо це відповідає вимогам.

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

З тієї ж причини, чому я в кількох вибраних екземплярах в таблицях SQL Server використовував BIGINT(64-бітове ціле число), а не INTEGER(32-бітове ціле число). Ймовірність того, що дані потраплять на 32-бітову межу протягом будь-якого розумного проміжку часу, є незначною, але якщо це станеться, наслідки в деяких ситуаціях можуть бути досить руйнівними. Просто не забудьте правильно зіставити типи між мовами, інакше ви зіткнетесь із цікавими дивацтвами дуже далеко ...

Це означає, що для деяких речей, таких як значення первинного ключа бази даних, підписані або непідписані насправді не має значення, оскільки, якщо ви вручну не ремонтуєте зламані дані чи щось за цими лініями, ви ніколи не маєте прямого значення зі значенням; це ідентифікатор, більше нічого. У цих випадках послідовність, ймовірно, важливіша, ніж точний вибір підписаності. В іншому випадку ви опинитесь підписаними стовпцями інших іноземних ключів та іншими, які не мають підпису, без явного шаблону - або знову ж таки цікавою дивністю.

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

Первинний раз, коли слід використовувати неподписані типи, це коли збирає декілька значень у більший (наприклад, перетворює чотири байти в 32-бітове число) або розкладає більші значення на менші (наприклад, зберігання 32-бітного числа у чотири байти) ), або коли у вас є кількість, яка, як очікується, періодично "перевертається", і потрібно з нею впоратися (подумайте про лічильник житлових комунальних послуг; у більшості з них достатньо цифр, щоб вони не змогли перевернутися між показаннями якщо їх читають три рази на рік, але недостатньо, щоб переконатися, що вони не перекидаються протягом строку корисного використання лічильника). Непідписані типи часто мають достатньо «дивацтва», що їх слід використовувати лише у випадках, коли необхідна їх семантика.

Я використовую непідписані вставки, щоб зробити свій код і його наміри більш зрозумілими. Одне, що я хочу захистити від несподіваних неявних перетворень, виконуючи арифметику як з підписаними, так і без підписаними типами, - це використовувати непідписаний короткий (зазвичай 2 байти) для моїх непідписаних змінних. Це ефективно з кількох причин:

• Якщо ви робите арифметику зі своїми непідписаними короткими змінними та літералами (які є тип int) або змінними типу int, це гарантує, що неподписана змінна завжди буде переведена в int перед оцінкою виразу, оскільки int завжди має більш високий ранг, ніж короткий . Це дозволяє уникнути будь-якої несподіваної поведінки, яка виконує арифметику з підписаними та непідписаними типами, припускаючи, що результат вираження вписується в підписаний int, звичайно.
• У більшості випадків непідписані змінні, які ви використовуєте, не перевищуватимуть максимальне значення непідписаного 2-байтового короткого (65,535)

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

Наприклад, нещодавно у мене було щось для циклу приблизно такого:

const unsigned short cuint = 5;
for(unsigned short i=0; i<10; ++i)
{
    if((i-2)%cuint == 0)
    {
       //Do something
    }
}

Буквальне '2' має тип int. Якщо я був непідписаним int замість непідписаного короткого, то в підвиразі (i-2) 2 буде переведено на безпідписаний int (оскільки unsigned int має більший пріоритет, ніж підписаний int). Якщо i = 0, то підвираз дорівнює (0u-2u) = деяке масивне значення через переповнення. Ідентична ідея з i = 1. Однак, оскільки i є непідписаним коротким, він переходить до того ж типу, що і буквальний '2', який підписаний int, і все працює добре.

Для додаткової безпеки: в рідкісному випадку, коли архітектура, яку ви реалізуєте, викликає, що int буде 2 байти, це може призвести до того, що обидва операнди в арифметичному виразі будуть переведені на безпідписаний int у випадку, коли непідписана коротка змінна не підходить в підписаний 2-байтний int, останній з яких має максимальне значення 32 767 <65,535. (Див. Https://stackoverflow.com/questions/17832815/c-implicit-conversion-signed-unsigned для отримання більш детальної інформації). Щоб захиститись від цього, ви можете просто додати static_assert до вашої програми наступним чином:

static_assert(sizeof(int) == 4, "int must be 4 bytes");

і не буде компілюватися в архітектурах, де int - 2 байти.