Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C

Negazione degli interi in C: promozioni e limiti

Dopo le promozioni intere applicabili, se il tipo è con segno, il meno unario restituisce l’opposto aritmetico se è rappresentabile in quel tipo; altrimenti il comportamento è indefinito. Per un tipo senza segno, il risultato si calcola modulo il massimo del tipo più uno.

Versione: ISO C23; implementation support may vary

Sintassi

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

La negazione unaria è un altro nome del meno unario (-x), non un operatore distinto. Questa nota riguarda il suo uso con gli interi. Il meno unario non va confuso con la negazione logica (!x).

Prima si applicano le promozioni intere previste; il tipo dopo la promozione è quello del risultato. Per esempio, short viene promosso a int, mentre in C23 un operando _BitInt che non è un campo di bit è esente. Se il tipo dopo la promozione è senza segno, il calcolo avviene modulo il massimo del tipo più uno: -1u dà UINT_MAX. In (size_t)-1 si ottiene prima il valore -1 di tipo int; la conversione a size_t dà SIZE_MAX.

In C23 l’opposto di INT_MIN non è rappresentabile come int. Valutare -x quando x è un int che vale INT_MIN ha quindi comportamento indefinito. Controlla x != INT_MIN prima di negarlo. Convertire il risultato, come in (long long)-x, non evita l’overflow. Il supporto per C23 varia in base all’implementazione.

Usa -1 come indicatore di errore o di assenza solo se lo prevede il contratto della funzione. Non memorizzarlo in un tipo senza segno se deve rimanere negativo. Riserva SIZE_MAX come sentinella soltanto se non può essere un risultato valido. In un comparatore di int, usa a < b e a > b invece di restituire a - b: la differenza può causare overflow agli estremi.

Esempi

#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;
}

Risultato

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

Il programma mostra la promozione di `short`, entrambe le uguaglianze con valori senza segno e il confronto fra gli estremi di `int`. Il controllo impedisce di valutare la negazione di `INT_MIN`.

Lezioni correlate

  • C · Lezione 63 · Avanzato · Versione: 3
  • C · Lezione 64 · Avanzato · Versione: 3
  • C · Lezione 65 · Avanzato · Versione: 3
  • C · Lezione 67 · Avanzato · Versione: 3
  • C · Lezione 70 · Avanzato · Versione: 3
  • C · Lezione 71 · Avanzato · Versione: 3
  • C · Lezione 72 · Avanzato · Versione: 3
  • C · Lezione 76 · Avanzato · Versione: 3
  • C · Lezione 80 · Avanzato · Versione: 3
  • C · Lezione 81 · Avanzato · Versione: 3

Fonti