Gli operatori di confronto sono operatori binari che verificano una condizione e restituiscono 1 se tale condizione è logicamente vera e 0 se tale condizione è falso.

Operatore Nome dell'operatore Esempio Descrizione
== uguale a a == b a è uguale a b
!= non è uguale a a != b a non è uguale a b
< minore di a < b a è inferiore a b
> maggiore di a > b a è maggiore di b
<= minore o uguale a a <= b a è minore o uguale a b
>= maggiore o uguale a a >= b a è maggiore o uguale a b

Operatori relazionali

Le espressioni degli operatori relazionali hanno la forma.

lhs<rhs (1)
lhs>rhs (2)
lhs<=rhs (3)
lhs>=dorsale (4)

1) espressione minore di 2) espressione maggiore di 3) espressione minore o uguale 4) espressione maggiore o uguale

dove.

lhs, rhs - espressioni che hanno entrambe un tipo reale o entrambe un puntatore a un tipo di oggetto

Il tipo di qualsiasi espressione dell'operatore relazionale è inte il suo valore (che non è un lvalue) è 1 quando la relazione specificata è vera e ​0​ quando la relazione specificata non è vera.

Se lhs e dorsale sono espressioni di qualsiasi tipo reale, allora.

  • vengono eseguite le consuete conversioni aritmetiche
  • i valori degli operandi dopo la conversione vengono confrontati nel senso matematico usuale (tranne che gli zeri positivi e negativi si confrontano in modo uguale e qualsiasi confronto che coinvolga un valore NaN restituisce zero)

Si noti che i numeri complessi e immaginari non possono essere confrontati con questi operatori.

Se lhs e dorsale sono espressioni di tipo puntatore, devono essere entrambi puntatori a oggetti di tipo compatibile, con la differenza che le qualifiche degli oggetti puntati vengono ignorate.

  • un puntatore a un oggetto che non è un elemento di una matrice viene trattato come se puntasse a un elemento di una matrice con un elemento.
  • se due puntatori puntano allo stesso oggetto, o entrambi puntano uno dopo la fine dello stesso array, si confrontano in modo uguale
  • se due puntatori puntano a elementi diversi dello stesso array, quello che punta all'elemento con l'indice più grande viene confrontato in modo maggiore.
  • se un puntatore punta a un elemento di una matrice e l'altro puntatore punta a un elemento successivo alla fine della stessa matrice, il puntatore che punta all'elemento successivo alla fine è maggiore.
  • se i due puntatori puntano a membri della stessa struttura, il puntatore al membro dichiarato più tardi nella definizione della struttura è maggiore del puntatore al membro dichiarato prima.
  • i puntatori a membri della stessa unione si confrontano in modo uguale
  • Tutti gli altri confronti tra puntatori comportano un comportamento non definito.
#includeintmain(void){assert(1<2);assert(2+2<=4.0);// int converts to double, two 4.0's compare equalstruct{int x,y;} s;assert(&s.x <&s.y);// struct members compare in order of declarationdouble d =0.0/0.0;// NaNassert(!(d < d));assert(!(d > d));assert(!(d >= d));assert(!(d >= d));float f =0.1;// f = 0.100000001490116119384765625double g =0.1;// g = 0.1000000000000000055511151231257827021181583404541015625assert(f > g);// different values}

Operatori di uguaglianza

Le espressioni dell'operatore di uguaglianza hanno la forma.

lhs==rhs (1)
lhs!=rhs (2)

1) espressione uguale a 2) non uguale all'espressione

dove.

lhs, rhs - espressioni che

  • hanno entrambe un qualsiasi tipo aritmetico (compresi complesso e immaginario)
  • sono entrambi puntatori a oggetti o funzioni di tipi compatibili, ignorando i qualificatori dei tipi puntati
  • uno è un puntatore a un oggetto e l'altro è un puntatore a una funzione (eventualmente qualificata) void
  • uno è un puntatore a un oggetto o a una funzione e l'altro è una costante a puntatore nullo, come ad esempio NULL

Il tipo di qualsiasi espressione dell'operatore di uguaglianza è inte il suo valore (che non è un valore l) è 1 quando la relazione specificata è vera e ​0​ quando la relazione specificata non è vera.

  • se entrambi gli operandi sono di tipo aritmetico, vengono eseguite le conversioni aritmetiche consuete e i valori risultanti vengono confrontati nel senso matematico consueto (tranne che gli zeri positivi e negativi si confrontano in modo uguale e qualsiasi confronto che coinvolga un valore NaN, compresa l'uguaglianza con se stesso, restituisce zero). In particolare, i valori di tipo complesso sono uguali se le loro parti reali sono uguali e le loro parti immaginarie sono uguali.
  • se un operando è un puntatore e l'altro è una costante di puntatore nullo, la costante di puntatore nullo viene prima convertita nel tipo di puntatore (che fornisce un valore di puntatore nullo), e i due puntatori vengono confrontati come descritto di seguito
  • se un operando è un puntatore e l'altro è un puntatore a void, il puntatore non-void viene convertito nel puntatore a void e i due puntatori vengono confrontati come descritto di seguito
  • due puntatori vengono confrontati in modo uguale se una delle seguenti condizioni è vera:
    • sono entrambi valori di puntatori nulli del tipo
    • sono entrambi puntatori allo stesso oggetto
    • un puntatore è a un oggetto struct/union/array e l'altro è al suo primo membro/qualsiasi membro/primo elemento
    • entrambi puntano all'ultimo elemento dello stesso array
    • uno è oltre la fine di un array e l'altro è all'inizio di un array diverso (dello stesso tipo) che segue il primo in un array più grande o in una struct senza padding

(come per gli operatori relazionali, i puntatori a oggetti che non sono elementi di alcun array si comportano come puntatori a elementi di array di dimensione 1).

Note

Gli oggetti di tipo struct non si confrontano automaticamente in modo uguale, e il confronto con memcmp non è affidabile perché i byte di riempimento possono avere qualsiasi valore.

Poiché il confronto dei puntatori funziona con i puntatori a void, la macro NULL può essere definita come (void*)0 in C, anche se non sarebbe valida in C++, dove i puntatori a void non si convertono implicitamente in puntatori tipizzati.

È necessario prestare attenzione quando si confrontano i valori in virgola mobile per verificarne l'uguaglianza, poiché i risultati di molte operazioni non possono essere rappresentati esattamente e devono essere arrotondati. In pratica, i numeri in virgola mobile vengono solitamente confrontati tenendo conto della differenza di una o più unità dell'ultimo posto.

#includeintmain(void){assert(2+2==4.0);// int converts to double, two 4.0's compare equalint n[2][3]={1,2,3,4,5,6};int* p1 =&n[0][2];// last element in the first rowint* p2 =&n[1][0];// start of second rowassert(p1+1== p2);// compare equaldouble d =0.0/0.0;// NaNassert( d != d );// NaN does not equal itselffloat f =0.1;// f = 0.100000001490116119384765625double g =0.1;// g = 0.1000000000000000055511151231257827021181583404541015625assert(f != g);// different values}

Riferimenti

  • Standard C11 (ISO/IEC 9899:2011):
    • 6.5.8 Operatori relazionali (p: 95-96)
    • 6.5.9 Operatori di uguaglianza (p: 96-97)
  • Standard C99 (ISO/IEC 9899:1999):
    • 6.5.8 Operatori relazionali (p: 85-86)
    • 6.5.9 Operatori di uguaglianza (p: 86-87)
  • Standard C89/C90 (ISO/IEC 9899:1990):
    • 3.3.8 Operatori relazionali
    • 3.3.9 Operatori di uguaglianza

Vedere anche

Precedenza degli operatori.

Operatori comuni
assegnazione incremento
decremento
aritmetico logico confronto membro
accesso
altro

a = b a += b a -= b a *= b a /= b a %= b a &= b a |= b a ^= b a <<= b a >>= b.

++a --a a++ a--

+a -a a + b a - b a * b a / b a % b ~a a & b a | b a ^ b a << b a >> b.

!a a && b a || b.

a == b a != b a < b a > b a <= b a >= b.

a[b] *a &a a->b a.b.

a(...) a, b (type) a ? : sizeof _Alignof(da C11).