¿Se define el comportamiento de la resta de enteros sin signo?

Me encontré con el código de alguien que parece creer que hay un problema al restar un entero sin signo de otro entero del mismo tipo cuando el resultado sería negativo. Entonces, ese código como este sería incorrecto incluso si funciona en la mayoría de las arquitecturas.

unsigned int To, Tf;

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

Esta es la única cita vagamente relevante del estándar C que pude encontrar.

Un cálculo que involucre operandos sin signo nunca puede desbordarse, porque un resultado que no puede ser representado por el tipo entero sin signo resultante se reduce módulo al número que es uno mayor que el valor más grande que puede ser representado por el tipo resultante.

Supongo que se podría tomar esa cita en el sentido de que cuando el operando derecho es más grande, la operación se ajusta para que sea significativa en el contexto de números truncados de módulo.

es decir

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

en lugar de utilizar la semántica firmada dependiente de la implementación:

0x0000 - 0x0001 == (sin firmar) (0 + -1) == (0xFFFF pero también 0xFFFE o 0x8001)

¿Cuál o qué interpretación es la correcta? ¿Está definido en absoluto?

El resultado de una resta que genera un número negativo en un tipo sin signo está bien definido:

1. [...] Un cálculo que involucra operandos sin signo nunca puede desbordarse, porque un resultado que no puede ser representado por el tipo entero sin signo resultante se reduce módulo al número que es uno mayor que el valor más grande que puede ser representado por el tipo resultante. (ISO / IEC 9899: 1999 (E) §6.2.5 / 9)

Como puede ver, (unsigned)0 - (unsigned)1es igual a -1 módulo UINT_MAX + 1, o en otras palabras, UINT_MAX.

Tenga en cuenta que, aunque dice "Un cálculo que implica operandos sin firmar nunca puede desbordarse", lo que podría llevarlo a creer que solo se aplica para exceder el límite superior, esto se presenta como una motivación para la parte vinculante real de la oración: "a el resultado que no puede ser representado por el tipo entero sin signo resultante se reduce módulo el número que es uno mayor que el valor más grande que puede ser representado por el tipo resultante. " Esta frase no se limita al desbordamiento del límite superior del tipo y se aplica igualmente a valores demasiado bajos para ser representados.

Cuando trabaja con tipos sin firmar , se lleva a cabo la aritmética modular (también conocida como comportamiento "envolvente" ). Para comprender esta aritmética modular , solo eche un vistazo a estos relojes:

9 + 4 = 1 ( 13 mod 12 ), entonces en la otra dirección es: 1 - 4 = 9 ( -3 mod 12 ). El mismo principio se aplica al trabajar con tipos sin firmar. Si el tipo de resultado es unsigned, entonces se lleva a cabo la aritmética modular.

Ahora observe las siguientes operaciones que almacenan el resultado como un 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

Cuando desee asegurarse de que el resultado sea signed, guárdelo en signedvariable o conviértalo en signed. Cuando desee obtener la diferencia entre números y asegurarse de que no se aplicará la aritmética modular, debe considerar usar la abs()función definida en stdlib.h:

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

Tenga mucho cuidado, especialmente al escribir las condiciones, porque:

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

pero

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

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

Bueno, la primera interpretación es correcta. Sin embargo, su razonamiento sobre la "semántica firmada" en este contexto es incorrecto.

Nuevamente, su primera interpretación es correcta. La aritmética sin signo sigue las reglas de la aritmética de módulo, lo que significa que se 0x0000 - 0x0001evalúa 0xFFFFpara tipos sin signo de 32 bits.

Sin embargo, la segunda interpretación (la basada en "semántica con signo") también es necesaria para producir el mismo resultado. Es decir, incluso si evalúa 0 - 1en el dominio de tipo firmado y obtiene -1como resultado intermedio, esto -1aún es necesario para producirlo 0xFFFFcuando más tarde se convierta a tipo sin firmar. Incluso si alguna plataforma utiliza una representación exótica para enteros con signo (complemento de 1, magnitud con signo), esta plataforma aún debe aplicar reglas de aritmética de módulo al convertir valores enteros con signo en valores sin signo.

Por ejemplo, esta evaluación

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

todavía está garantizado para producir UINT_MAXen c, incluso si la plataforma está utilizando una representación exótica para enteros con signo.

Con números sin signo de tipo unsigned into mayor, en ausencia de conversiones de tipo, a-bse define como el resultado del número sin signo que, cuando se agrega b, dará como resultado a. La conversión de un número negativo a sin signo se define como el resultado del número que, cuando se agrega al número original con signo invertido, dará como resultado cero (por lo tanto, convertir -5 a sin signo arrojará un valor que, cuando se suma a 5, dará como resultado cero) .

Tenga en cuenta que los números sin signo más pequeños que unsigned intpueden ser promocionados a tipografía intantes de la resta, el comportamiento de a-bdependerá del tamaño de int.