Linguaggio C - Espressioni ed operatori

Il programma C e' una sequenza di espressioni, pertanto gli operatori vengono largamente utilizzati.
Un'espressione puo' essere definita come il risultato dell'applicazione di una o piu' righe sotto riportate:
o espr ::= (espr)
o espr ::= espr op espr
  (Dove op e' un operatore binario)
o espr ::= op espr
  (Dove op e' un operatore unario)
o espr ::= variablie++
o espr ::= variablie--
o espr ::= variabile
o espr ::= funzione
o espr ::= costante

Di seguito e' brevemente riportata una descrizione di ciascun operatore con le sue caratteristiche principali.

Elenco operatori del C

Operatori aritmetici

+ Operatore aritmetico di somma.
Effettua l'operazione di somma fra 2 espressioni.
- Operatore aritmetico di sottrazione.
Effettua l'operazione di differenza fra 2 espressioni.
* Operatore aritmetico di moltiplicazione.
Effettua l'operazione di moltiplicazione fra 2 espressioni.
/ Operatore aritmetico di divisione.
Effettua l'operazione di divisione fra 2 espressioni.
% Operatore aritmetico di modulo.
Calcola il resto della divisone fra la 1° ed la 2° espressione.
Funziona con espressioni che tornino valori interi (char, int, long).
- Operatore unario di cambio segno.
-espressione
Cambia il segno all'intera espressione.
+ Operatore unario +
+espressione
Equivale a espressione.
++ Operatore di incremento.
Puo' essere impiegato sia in forma postfissa (es: variabile++) che in forma prefissa (es: ++variabile).
In entrambi i casi le due forme sono equivalenti a:
variabile = variabile + 1;
Nella forma postfissa l'incremento viene effettuato dopo dell'utilizzo della variabile.
Nella forma prefissa l'incremento viene effettuato prima dell'utilizzo della variabile.
Esempio: 
  int i;                /* indice */
  char v[10];           /* array (vettore) di 10 caratteri */

  i=0;
  v[i++] = 'A';         /* v[0]='A' e i=1 */

  i=0;
  v[++i] = 'a';         /* i=1 e v[1]='a' */
-- Operatore di decremento.
Valgono le stesse considerazioni effettuate per l'operatore di incremento ++, tranne il fatto che le forme variabile-- e --variabile equivalgono a:
variabile = variabile - 1;

Operatori relazionali

== Operatore relazionale di uguaglianza.
Ritorna 1 (vero) se le 2 espressioni ritornano valori uguali.
Ritorna 0 (falso) in caso contrario.
!= Operatore relazionale di disuguaglianza.
Ritorna 1 (vero) se le 2 espressioni ritornano valori differenti.
Ritorna 0 (falso) in caso contrario.
< Operatore relazionale di minoranza.
Ritorna 1 (vero) se il valore ritornato dalla 1° espressione e' minore del valore ritornato dalla 2° espressione.
Ritorna 0 (falso) in caso contrario.
<= Operatore relazionale di minoranza o uguaglianza.
Ritorna 1 (vero) se il valore ritornato dalla 1° espressione e' minore o uguale (cioe' non maggiore) al valore ritornato dalla 2° espressione.
Ritorna 0 (falso) in caso contrario.
> Operatore relazionale di maggioranza.
Ritorna 1 (vero) se il valore ritornato dalla 1° espressione e' maggiore del valore ritornato dalla 2° espressione.
Ritorna 0 (falso) in caso contrario.
>= Operatore relazionale di maggioranza o uguaglianza.
Ritorna 1 (vero) se il valore ritornato dalla 1° espressione e' maggiore o uguale (cioe' non minore) al valore ritornato dalla 2° espressione.
Ritorna 0 (falso) in caso contrario.

Operatori logici

! Operatore logico di negazione. (unario)
!espressione ritorna 0 se espressione ritorna un valore diverso da 0; ritorna 1 se espressione ritorna il valore uguale a 0.
&& Operatore logico and.
Esegue l'and logico fra 2 espressioni.
Valuta la prima espressione e se questa e' falsa, ritorna 0 senza valutare la seconda; altrimenti valuta la seconda espressione. Se quest'ultima e' falsa ritorna 0 altrimenti ritorna 1.
|| Operatore logico or.
Esegue l'or logico fra 2 espressioni.
Valuta la prima espressione e se questa e' vera, ritorna 1 senza valutare la seconda; altrimenti valuta la seconda espressione. Se quest'ultima e' vera ritorna 1 altrimenti ritorna 0.

Operatori bit a bit

~ Operatore complemento ad 1 (unario).
~espressione ritorna il complemento ad 1 del valore tornato da espressione.
Il complemento ad 1 consiste nel cambio di ciascun bit con il suo complemento, ovvero ogni bit posto ad 1 viene cambiato a 0 ed ogni bit posto a 0 viene cambiato ad 1.
& Operatore and bit a bit.
Ritorna il valore dell'and effettuato bit a bit sui valori ritornati dalle 2 espressioni.
Esempio: 
  int a=10;             /* rappresentazione binaria (8 bit): 00001010 */
  int b=12;             /* rappresentazione binaria (8 bit): 00001100 */
  int c;

  c = a&b;              /*  00001010    a
                         *  00001100    b
                         *  --------
                         *  00001000    c = a&b */
N.B. - Per semplicita' di trattazione, sono stati considerati gli interi come costituiti da 8 bit, anziche' 16 o 32 bit come avviene in realta' sugli elaboratori.
| Operatore or (inclusivo) bit a bit.
Ritorna il valore dell'or effettuato bit a bit sui valori ritornati dalle 2 espressioni.
Esempio: 
  int a=10;             /* rappresentazione binaria (8 bit): 00001010 */
  int b=12;             /* rappresentazione binaria (8 bit): 00001100 */
  int c;

  c = a|b;              /*  00001010    a
                         *  00001100    b
                         *  --------
                         *  00001110    c = a|b */
N.B. - Per semplicita' di trattazione, sono stati considerati gli interi come costituiti da 8 bit, anziche' 16 o 32 bit come avviene in realta' sugli elaboratori.
^ Operatore or esclusivo (ex-or) bit a bit.
Ritorna il valore dell'ex-or effettuato bit a bit sui valori ritornati dalle 2 espressioni.
Esempio: 
  int a=10;             /* rappresentazione binaria (8 bit): 00001010 */
  int b=12;             /* rappresentazione binaria (8 bit): 00001100 */
  int c;

  c = a^b;              /*  00001010    a
                         *  00001100    b
                         *  --------
                         *  00000110    c = a^b */
N.B. - Per semplicita' di trattazione, sono stati considerati gli interi come costituiti da 8 bit, anziche' 16 o 32 bit come avviene in realta' sugli elaboratori.
<< Operatore shift a sinistra.
espr_1 << espr_2
Ritorna il valore della traslazione a sinistra di espr_2 bit sui bit del valore ritornato da espr_1.
I nuovi bit che entrano a destra sono posti a 0.
Esempio: 
  int a=10;             /* rappresentazione binaria (8 bit): 00001010 */
  int b=2;
  int c;

  c = a<<b;             /*  c = 00101000  = 40 */
N.B. - Per semplicita' di trattazione, sono stati considerati gli interi come costituiti da 8 bit, anziche' 16 o 32 bit come avviene in realta' sugli elaboratori.
>> Operatore shift a destra.
espr_1 >> espr_2
Ritorna il valore della traslazione a destra di espr_2 bit sui bit del valore ritornato da espr_1.
I nuovi bit che entrano a sinistra possono dipendere dall'architettura dell'elaboratore e/o dalla implementazione del compilatore. Non e' garantito che siano sempre posti a 0 anche per valori negativi di espr_1; per evitare cio' e' bene assicurarsi che il valore ritornato da espr_1 sia di tipo unsigned
Esempio: 
  unsigned int a=10;    /* rappresentazione binaria (8 bit): 00001010 */
  int b=2;
  int c;

  c = a>>b;             /*  c = 00000010  = 2 */
N.B. - Per semplicita' di trattazione, sono stati considerati gli interi come costituiti da 8 bit, anziche' 16 o 32 bit come avviene in realta' sugli elaboratori.

Operatori di assegnamento

= Operatore di assegnamento.
Utilizzato per assegnare il valore di una espressione ad una variablile.
L'assegnamento produce sempre un valore, pertanto puo' essere incluso all'interno di espressioni piu' complesse a condizione di una perdita della leggibilita' del codice sorgente.
Piu' frequentemente e' utilizzato per effettuare delle assegnazioni multliple.
Esempio di assegnazione multipla:
  i = k = l = 0;        /* ad i,  k, l viene assegnato il valore 0 */
op= Operatori di assegnamento.
op e' uno degli operatori + - * / % & | ^ << >>
L'espressione:
var op= espr
e' equivalente alla espressione:
var = (var) op (espr)
tranne per il fatto che var e' valutata solamente 1 volta nel 1° caso e 2 volte nel 2° caso. Questo ha influenza quando var puo' dar luogo a effetti collaterali (o side effect).
Esempio:
a[i++] += 5;
non equivale a
a[i++] = a[i++] + 5;

Altri operatori

() Operatore di cambio priorita'.
L'espressione contenuta all'interno della coppia di parantesi () viene eseguita con priorita' piu' alta, rispetto all'espressione all'eserno delle parentesi.
Vedi anche le precedenze degli operatori.
(tipo) Operatore di conversione tipo (casting).
Forza l'espressione seguente al tipo specificato fra parentesi.
Vedi anche le conversioni di tipo.
[] Operatore di accesso ad un elemento di un array.
Viene valutata l'espressione all'interno della coppia di parenesi [] ed il valore ritornato (che deve essere intero) viene impiegato per accedere all'array.
Esempio:
a[5]
& Operatore di indirizzo.
Ritorna l'indirizzo della variabile di memoria a cui e' applicato.
Esempio:
&a
* Operatore per l'accesso da puntatore (dereferencing).
Permette l'accesso ad un elemento di memoria il cui indirizzo e' contenuto in un puntatore.
Esempio:
*p
. Operatore di accesso ad un campo di una struttura (o di una union).
Permette di accedere ad un campo facente parte di una struttura o di una union.
Esempio:
data.giorno
-> Operatore di accesso ad un campo di una struttura (o di una union) puntata.
Permette di accedere ad un campo di una struttura o di una union puntata da un puntatore, scrivendo un codice piu' compatto e piu' leggibile, piuttosto che utilizzare gli elementi del linguaggio () . * piu' sopra definiti.
Vedi i tipi complessi.
Esempio:
p->giorno
sizeof Operatore di dimensione di una variabile o di un tipo.
Ritorna la dimensione in byte occupata dalla variabile o necessaria per il tipo a cui l'operatore viene applicato.
Esempio:
sizeof(long)
?: Operatore condizionale.
espr_1 ? espr_2 : espr_3
Viene valutata espr_1. Se questa risulta vera (cioe' torna un valore diverso da 0) viene valutata e viene ritornato il valore di espr_2; altrimenti di espr_3.
Equivale "quasi" al codice: 
  if (espr_1)
    espr_2;
  else
    espr_3;
tranne per il fatto che il valore restituito dall'operatore condizionale e' rappresentato da espr_2 o da espr_3.
Esempio: 
  int a, b, max;
  ...
  max = (a > b) ? a : b;     /* max contiene il massimo fra a, b */
N.B. - Nell'esempio sopra riportato, l'uso delle parentesi e' superfluo (migliorano la leggibilita').
Vedi anche le precedenze fra operatori.
, Operatore di concatenazione.
Concatena piu' espressioni.
L'espressione concatenata assume il valore dell'ultima espressione da concatenare.
Esempio: 
  x=10, y=0;            /* l'intera espressione assume il valore 0 */

Nota sugli operatori logici

Nel C il valore 0 viene considerato come valore logico FALSO, mentre un valore diverso da 0 e' considerato come valore logico VERO. Pertanto gli operatori logici ! && || riconoscono in ingresso il valore 0 come condizione di falsita' ed ogni altro valore come condizione di verita'.
Nel C gli operatori logici ritornano, invece, sempre uno dei due valori 0 o 1.

Indice-C Indice linguaggio C
At Home Umberto Zappi Home Page