Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C

Negación de enteros en C: promociones y límites

Tras aplicar las promociones de enteros pertinentes, si el tipo es con signo, el menos unario da el opuesto aritmético siempre que sea representable en ese tipo; de lo contrario, el comportamiento es indefinido. Para un tipo sin signo, el resultado se calcula módulo el máximo del tipo más uno.

Versión: ISO C23; implementation support may vary

Sintaxis

- cast-expression
Examples: -x, -(a + b), -1, (size_t)-1

La negación unaria es otro nombre del menos unario (-x), no un operador distinto. Esta nota se centra en su uso con enteros. No lo confundas con la negación lógica (!x).

Primero se aplican las promociones de enteros pertinentes; el tipo tras la promoción es el del resultado. Por ejemplo, short se promociona a int, mientras que en C23 un operando _BitInt que no es un campo de bits queda exento. Si el tipo tras la promoción es sin signo, se calcula módulo el máximo de ese tipo más uno: -1u da UINT_MAX. En (size_t)-1, primero se obtiene el valor -1 de tipo int; al convertirlo a size_t se obtiene SIZE_MAX.

En C23, el opuesto de INT_MIN no cabe en int. Evaluar -x cuando x es un int con valor INT_MIN da lugar a comportamiento indefinido. Comprueba x != INT_MIN antes de negarlo. Convertir el resultado, como en (long long)-x, no evita el desbordamiento. La compatibilidad con C23 depende de la implementación.

Usa -1 para indicar error o ausencia solo si el contrato de la función lo establece. No lo guardes en un tipo sin signo si debe seguir siendo negativo. Reserva SIZE_MAX como centinela solo si no puede ser un resultado válido. En un comparador de int, usa a < b y a > b en vez de devolver a - b: la diferencia puede desbordarse en los extremos.

Ejemplos

#include <limits.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>

static int compare_ints(int a, int b)
{
    return a < b ? -1 : (a > b ? 1 : 0);
}

int main(void)
{
    short n = 7;
    int x = INT_MIN;
    size_t missing = (size_t)-1;

    printf("-n = %d\n", -n);
    printf("-1u == UINT_MAX: %d\n", -1u == UINT_MAX);
    printf("missing == SIZE_MAX: %d\n", missing == SIZE_MAX);
    printf("compare(INT_MIN, INT_MAX) = %d\n", compare_ints(x, INT_MAX));

    if (x == INT_MIN) {
        puts("INT_MIN: negation skipped");
    } else {
        printf("-x = %d\n", -x);
    }
    return 0;
}

Resultado

-n = -7
-1u == UINT_MAX: 1
missing == SIZE_MAX: 1
compare(INT_MIN, INT_MAX) = -1
INT_MIN: negation skipped

El programa muestra la promoción de `short`, ambas igualdades con valores sin signo y la comparación de los extremos de `int`. La comprobación evita evaluar la negación de `INT_MIN`.

Lecciones relacionadas

  • C · Lección 63 · Avanzado · Versión: 3
  • C · Lección 64 · Avanzado · Versión: 3
  • C · Lección 65 · Avanzado · Versión: 3
  • C · Lección 67 · Avanzado · Versión: 3
  • C · Lección 70 · Avanzado · Versión: 3
  • C · Lección 71 · Avanzado · Versión: 3
  • C · Lección 72 · Avanzado · Versión: 3
  • C · Lección 76 · Avanzado · Versión: 3
  • C · Lección 80 · Avanzado · Versión: 3
  • C · Lección 81 · Avanzado · Versión: 3

Fuentes