La sottrazione di interi senza segno è definita un comportamento?

Mi sono imbattuto nel codice di qualcuno che sembra credere che ci sia un problema durante la sottrazione di un numero intero senza segno da un altro intero dello stesso tipo quando il risultato sarebbe negativo. Quindi quel codice come questo non sarebbe corretto anche se dovesse funzionare sulla maggior parte delle architetture.

unsigned int To, Tf;

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

Questa è l'unica citazione vagamente rilevante dallo standard C che sono riuscito a trovare.

Un calcolo che coinvolge operandi senza segno non può mai superare il flusso, perché un risultato che non può essere rappresentato dal tipo intero senza segno risultante viene ridotto modulo il numero che è maggiore di uno rispetto al valore più grande che può essere rappresentato dal tipo risultante.

Suppongo che si possa prendere quella citazione per significare che quando l'operando destro è più grande l'operazione viene regolata per essere significativa nel contesto dei numeri troncati del modulo.

cioè

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

invece di usare la semantica firmata dipendente dall'implementazione:

0x0000 - 0x0001 == (senza segno) (0 + -1) == (0xFFFF ma anche 0xFFFE o 0x8001)

Quale o quale interpretazione è giusta? È definito del tutto?

Il risultato di una sottrazione che genera un numero negativo in un tipo senza segno è ben definito:

1. [...] Un calcolo che coinvolge operandi senza segno non può mai eccedere, perché un risultato che non può essere rappresentato dal tipo intero senza segno risultante viene ridotto modulo il numero che è maggiore di uno del valore più grande che può essere rappresentato dal tipo risultante. (ISO / IEC 9899: 1999 (E) §6.2.5 / 9)

Come puoi vedere, è (unsigned)0 - (unsigned)1uguale a -1 modulo UINT_MAX + 1, o in altre parole, UINT_MAX.

Nota che anche se dice "Un calcolo che coinvolge operandi non firmati non può mai eccedere", il che potrebbe farti credere che si applica solo per il superamento del limite superiore, questo è presentato come una motivazione per la parte vincolante effettiva della frase: "a il risultato che non può essere rappresentato dal tipo intero senza segno risultante viene ridotto modulo il numero maggiore di uno rispetto al valore più grande che può essere rappresentato dal tipo risultante. " Questa frase non si limita all'overflow del limite superiore del tipo e si applica allo stesso modo ai valori troppo bassi per essere rappresentati.

Quando si lavora con tipi senza segno , si verifica un'aritmetica modulare (nota anche come comportamento "avvolgente" ). Per capire questa aritmetica modulare , basta dare un'occhiata a questi orologi:

9 + 4 = 1 ( 13 mod 12 ), quindi nell'altra direzione è: 1 - 4 = 9 ( -3 mod 12 ). Lo stesso principio viene applicato quando si lavora con i tipi senza segno. Se il tipo di risultato è unsigned, ha luogo l'aritmetica modulare.

Ora guarda le seguenti operazioni che memorizzano il risultato come 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

Quando vuoi assicurarti che il risultato sia signed, memorizzalo in signedvariabile o eseguirne il cast signed. Quando vuoi ottenere la differenza tra i numeri e assicurarti che l'aritmetica modulare non venga applicata, dovresti considerare l'utilizzo della abs()funzione definita in stdlib.h:

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

Fai molta attenzione, soprattutto durante la scrittura delle condizioni, perché:

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

ma

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

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

Ebbene, la prima interpretazione è corretta. Tuttavia, il tuo ragionamento sulla "semantica con segno" in questo contesto è sbagliato.

Di nuovo, la tua prima interpretazione è corretta. Follow aritmetica senza segno le regole del modulo aritmetica, il che significa che 0x0000 - 0x0001restituisce 0xFFFFper 32 bit senza segno tipi.

Tuttavia, anche la seconda interpretazione (quella basata sulla "semantica con segno") è necessaria per produrre lo stesso risultato. Vale a dire, anche se si valuta 0 - 1nel dominio di tipo firmato e si ottiene -1come risultato intermedio, questo -1è ancora necessario per produrre 0xFFFFquando successivamente viene convertito in tipo non firmato. Anche se alcune piattaforme utilizzano una rappresentazione esotica per interi con segno (complemento di 1, grandezza con segno), questa piattaforma è ancora richiesta per applicare le regole dell'aritmetica del modulo durante la conversione di valori interi con segno in valori senza segno.

Ad esempio, questa valutazione

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

è ancora garantita per produrre UINT_MAXin c, anche se la piattaforma sta usando una rappresentazione esotica per gli interi con segno.

Con numeri di tipo senza segno unsigned into maggiori, in assenza di conversioni di tipo, a-bsi definisce che restituisce il numero senza segno che, se aggiunto b, produrrà a. La conversione di un numero negativo in unsigned è definita come la resa del numero che, quando aggiunto al numero originale con segno invertito, restituirà zero (quindi convertire -5 in unsigned produrrà un valore che, se aggiunto a 5, produrrà zero) .

Nota che i numeri senza segno più piccoli di unsigned intpossono essere promossi al tipo intprima della sottrazione, il comportamento di a-bdipenderà dalla dimensione di int.