Чи визначено поведінку без підписаного цілого віднімання?

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

unsigned int To, Tf;

To = getcounter();
while (1) {
    Tf = getcounter();
    if ((Tf-To) >= TIME_LIMIT) {
        break;
    } 
}

Це єдина нечітко відповідна цитата зі стандарту С, яку я міг знайти.

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

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

тобто

0x0000 - 0x0001 == 0x 1 0000 - 0x0001 == 0xFFFF

на відміну від використання підписаної семантики, залежної від реалізації:

0x0000 - 0x0001 == (без підпису) (0 + -1) == (0xFFFF, але також 0xFFFE або 0x8001)

Яке чи яке тлумачення є правильним? Чи визначено це взагалі?

Результат віднімання, що генерує від'ємне число у неподписаному типі, є чітко визначеним:

1. [...] Обчислення, що включають непідписані операнди, ніколи не можуть переповнюватись, оскільки результат, який не може бути представлений результатом непідписаного цілого типу, зменшується за модулем на число, яке на одну величину більше, ніж найбільше значення, яке може бути представлено отриманим типом. (ISO / IEC 9899: 1999 (E) § 6.2.5 / 9)

Як бачимо, (unsigned)0 - (unsigned)1дорівнює -1 модуль UINT_MAX + 1, або іншими словами, UINT_MAX.

Зауважте, що хоч це говорить: "Обчислення, що включають непідписані операнди, ніколи не можуть переповнювати", що може привести вас до думки, що воно застосовується лише для перевищення верхньої межі, це подається як мотивація фактичної обов'язкової частини речення: "a Результат, який не може бути представлений отриманим неподписаним цілим типом, зменшується по модулю на число, яке на одне більше, ніж найбільше значення, яке може бути представлено отриманим типом. " Ця фраза не обмежується переповненням верхньої межі типу і застосовується однаково до значень, занадто низьких, щоб бути представленими.

Коли ви працюєте з непідписаними типами, відбувається модульна арифметика (також відома як поведінка "обернути навколо" ). Щоб зрозуміти цю модульну арифметику , просто подивіться на ці години:

9 + 4 = 1 ( 13 мод 12 ), тому в інший бік це: 1 - 4 = 9 ( -3 mod 12 ). Цей же принцип застосовується під час роботи з неподписаними типами. Якщо тип результату є unsigned, то відбувається модульна арифметика.

Тепер подивіться на наступні операції, що зберігають результат як unsigned int:

unsigned int five = 5, seven = 7;
unsigned int a = five - seven;      // a = (-2 % 2^32) = 4294967294 

int one = 1, six = 6;
unsigned int b = one - six;         // b = (-5 % 2^32) = 4294967291

Коли ви хочете переконатися в тому, що результат є signed, тоді зберігайте його в signedзмінній або передайте його signed. Якщо ви хочете отримати різницю між числами і переконатися, що модульна арифметика не буде застосована, то слід розглянути можливість використання abs()функції, визначеної у stdlib.h:

int c = five - seven;       // c = -2
int d = abs(five - seven);  // d =  2

Будьте дуже обережні, особливо під час написання, тому що:

if (abs(five - seven) < seven)  // = if (2 < 7)
    // ...

if (five - seven < -1)          // = if (-2 < -1)
    // ...

if (one - six < 1)              // = if (-5 < 1)
    // ...

if ((int)(five - seven) < 1)    // = if (-2 < 1)
    // ...

але

if (five - seven < 1)   // = if ((unsigned int)-2 < 1) = if (4294967294 < 1)
    // ...

if (one - six < five)   // = if ((unsigned int)-5 < 5) = if (4294967291 < 5)
    // ...

Ну, перше тлумачення правильне. Однак Ваші міркування про "підписану семантику" в цьому контексті помилкові.

Знову ж таки, ваше перше тлумачення правильне. Беззнаковий арифметична слідувати правилам арифметики по модулю, а це означає , що має 0x0000 - 0x0001значення 0xFFFFдля 32-бітних беззнакових типів.

Однак друге тлумачення (те, яке ґрунтується на «підписаній семантиці») також вимагає того ж результату. Тобто, навіть якщо ви оцінюєте 0 - 1домен підписаного типу і отримуєте -1як проміжний результат, це -1все одно потрібно виробляти, 0xFFFFколи пізніше він переходить у неподписаний тип. Навіть якщо деяка платформа використовує екзотичне подання для підписаних цілих чисел (доповнення 1, величина з підписами), ця платформа все одно зобов'язана застосовувати правила модульної арифметики під час перетворення підписаних цілих цілих чисел у неподписані цілі.

Наприклад, це оцінювання

signed int a = 0, b = 1;
unsigned int c = a - b;

по - , як і раніше гарантовано виробляти UINT_MAXв c, навіть якщо платформа використовує екзотичне уявлення для цілих чисел.

З безпідписаними числами типу unsigned intабо більше, за відсутності перетворень типу, a-bвизначається як отримання неподписаного числа, яке при додаванні bдасть результат a. Перетворення від'ємного числа в непідписане визначається як отримання числа, яке при додаванні до знака, оберненого знаком, поверне нулю (тому перетворення -5 в неподписане дасть значення, яке при додаванні до 5 приведе до нуля) .

Зауважте, що безпідписані числа менші, ніж unsigned intможуть бути запропоновані до введення intдо віднімання, поведінка a-bбуде залежати від розміру int.