C Language Operatori logici

Esempio

AND logico

Esegue un AND logico booleano dei due operandi restituendo 1 se entrambi gli operandi sono diversi da zero. L'operatore AND logico è di tipo int .

0 && 0  /* Returns 0. */
0 && 1  /* Returns 0. */
2 && 0  /* Returns 0. */
2 && 3  /* Returns 1. */

OR logico

Esegue un OR logico booleano dei due operandi restituendo 1 se uno degli operandi è diverso da zero. L'operatore logico OR è di tipo int .

0 || 0  /* Returns 0. */
0 || 1  /* Returns 1.  */
2 || 0  /* Returns 1.  */
2 || 3  /* Returns 1.  */

NOT logico

Esegue una negazione logica. L'operatore logico NOT è di tipo int . L'operatore NOT verifica se almeno un bit è uguale a 1, in tal caso restituisce 0. Altrimenti restituisce 1;

!1 /* Returns 0. */
!5 /* Returns 0. */
!0 /* Returns 1. */

Valutazione del cortocircuito

Ci sono alcune proprietà cruciali comuni a && e || :

  • l'operando di sinistra (LHS) è completamente valutato prima di valutare l'operando di destra (RHS),
  • c'è un punto di sequenza tra la valutazione dell'operando di sinistra e l'operando di destra,
  • e, soprattutto, l'operando di destra non viene valutato affatto se il risultato dell'operando di sinistra determina il risultato complessivo.

Ciò significa che:

  • se l'LHS valuta "vero" (diverso da zero), l'RHS di || non sarà valutato (perché il risultato di 'true OR anything' è 'true'),
  • se l'LHS restituisce 'false' (zero), l'RHS di && non verrà valutato (perché il risultato di 'false AND anything' è 'false').

Questo è importante in quanto ti permette di scrivere codice come:

const char *name_for_value(int value)
{
    static const char *names[] = { "zero", "one", "two", "three", };
    enum { NUM_NAMES = sizeof(names) / sizeof(names[0]) };
    return (value >= 0 && value < NUM_NAMES) ? names[value] : "infinity";
}

Se un valore negativo viene passato alla funzione, il value >= 0 termine value < NUM_NAMES false e il value < NUM_NAMES non viene valutato.