Introduzione al Linguaggio C

di C. Munisso

Capitolo 3 - Espressioni e operatori

3.2. Operatori

3.2.1 Categorie e tavola degli operatori

Gli operatori del C si possono dividere nelle sei seguenti categorie: Presentiamo ora una tavola riassuntiva degli operatori prima di trattarne più dettagliatamente.

Operatori primari
Operatore Esempio Risultato
[] x[y] array x di y elementi
() x() chiamata alla funzione x
. x.y riferimento a y di x
-> x->y riferimento a y di x (per puntatore)

Operatori unari
Operatore Esempio Risultato
* *x puntatore all'oggetto all'indirizzo x
& &x indirizzo della variabile x
- -x negativo di x
~ ~x complemento a 1 di x
++ (prefisso) ++x pre-incremento di x
++ (postfisso) x++ post-incremento di x
-- (prefisso) --x pre-decremento di x
-- (postfisso) x-- post-decremento di x
sizeof sizeof(x) numero di byte di x
(tipo) (t)x conversione di x in tipo t
! !x NOT logico su x (produce 0 o 1)

Operatori binari
Operatore Esempio Risultato
= x = y y assegnato a x
+ x + y x più y
- x - y x meno y
* x * y x volte y
/ x / y x diviso y
% x % y resto di x/y (x modulo y)
> x > y 1 se x superiore a y; altrimenti 0
< x < y 1 se x inferiore a y; altrimenti 0
>= x >= y 1 se x superiore o uguale a y; altr. 0
<= x <= y 1 se x inferiore o uguale a y; altr. 0
== x == y 1 se x uguale a y; altrimenti 0
!= x != y 1 se x diverso da y; altrimenti 0
&& x && y AND logico tra x e y (produce 0 o 1)
|| x || y OR logico tra x e y (produce 0 o 1)
>> x >> y x shiftato a destra di y bit
<< x << y x shiftato a sinistra di y bit
& x & y AND sul bit tra x e y
| x | y OR sul bit tra x e y
^ x ^ y XOR (OR esclusivo) sul bit tra x e y
, e1, e2 e2 (e1 valutata prima)

Operatori ternari.
Operatore Esempio Risultato
? : x:e1?e2 espressione e1 se x diverso da zero, espressione e2 se x uguale a zero

3.2.2 Priorità ed associatività

Gli operatori, naturalmente, sottostanno a precise regole di priorità e di associatività. La seguente tavola presenta queste regole, il valore minore sulla colonna precedenza costituisce il livello maggiore.

Tavola della precedenza ed associatività degli operatori
Precedenza Categoria Operatori Associatività
1 Primari () [] -> . sinistra-destra
2 Unari ! ~ ++ -- * & destra-sinistra
2 Unari (tipo)sizeof destra-sinistra
3 Binari * / % sinistra-destra
4 Binari + - sinistra-destra
5 Binari >> << sinistra-destra
6 Binari < <= > >= sinistra-destra
7 Binari == != sinistra-destra
8 Binari & sinistra-destra
9 Binari ^ sinistra-destra
10 Binari | sinistra-destra
11 Binari && sinistra-destra
12 Binari || sinistra-destra
13 Condizionali ?: destra-sinistra
14 Assegnazione = destra-sinistra
15 Virgola , sinistra-destra

3.2.3 Operatori binari

Come abbiamo visto nella tavola degli operatori, gli operatori binari costituiscono il gruppo più numeroso.

Questi operatori si possono suddividere ulteriormente nelle seguenti categorie:
Vediamo ora nel dettaglio queste categorie.

3.2.3.1 Operatore di assegnazione

L'operatore di assegnazione è rappresentato con il segno di uguaglianza = e richiede due operandi, uno alla sua sinistra ed uno alla sua destra, l'operando di destra può essere una espressione e viene risolto per primo come possiamo vedere dalla tavola della precedenza ed associatività degli operatori.
Nella forma:

a = b + c;

 l'espressione b+c viene risolta per prima e quindi viene effettuato l'assegnamento alla variabile a (associatività destra-sinistra). L'operatore di assegnazione può a sua volta essere una espressione quando viene usato in combinazione con alcuni altri operatori binari. Questa caratteristica permette di utilizzare alcune forme abbreviate di operatori, questo aspetto verrà illustrato più dettagliatamente nel paragrafo relativo alle espressioni di assegnazione.

3.2.3.2 Operatori additivi

Gli operatori di addizione + e sottrazione - seguono le regole aritmetiche per la conversione di segno degli operandi quando questi sono dei valori interi o in virgola mobile (int, float, double). È possibile con questi operatori effettuare incrementi e decrementi su puntatori, addizionando o sottraendo valori interi, il compilatore calcola la dimensione del tipo del puntatore al fine di ottenere l'offset necessario al corretto indirizzamento della variabile.

Le operazioni di aritmetica sui puntatori vengono usualmente effettuate con gli array per indirizzare ai singoli elementi. Vediamo ora con un esempio quanto affermato:

001 Dichiarazione delle variabili: due array, short int e long int, di tre elementi ciascuno e due puntatori rispettivamente a short int e a long int (notiamo che il qualificatore int è implicito).

002 Assegnazione di valori agli elementi degli array.

003 Assegnazione ai puntatori pa e pb degli indirizzi del primo elemento degli array e restituzione degli indirizzi e dei valori.

004 Incremento di due unità ai puntatori pa e pb e restituzione degli indirizzi e dei valori. Notiamo che ora viene restituito il terzo elemento degli array e che l'offset è di 4 locazioni di memoria per il puntatore a short (pa) e 8 locazioni per il puntatore a long (pb). Ricordiamo che il sistema Unix utilizzato per l'esempio restituisce il numero della locazione di memoria in forma esadecimale.

005 Decremento di una unità al puntatori pa e pb e restituzione degli indirizzi e dei valori, ora viene restituito il secondo elemento degli array e offset è di 2 locazioni per pa e 4 locazioni per pb.

Il programma restituisce il seguente output su un sistema Unix:

array a indirizzo 7fffbb30, valore: 34
array b indirizzo 7fffbb20, valore: 1234

array a indirizzo 7fffbb34, valore: 26
array b indirizzo 7fffbb28, valore: 15000

array a indirizzo 7fffbb32, valore: 4
array b indirizzo 7fffbb24, valore: 4000

 ed il seguente su un sistema MS-DOS:

array a indirizzo 0FFA, valore: 34
array b indirizzo 0FE6, valore: 1234

array a indirizzo 0FFE, valore: 26
array b indirizzo 0FEE, valore: 15000

array a indirizzo 0FFC, valore: 4
array b indirizzo 0FEA, valore: 4000

3.2.3.3 Operatori moltiplicativi

Questi operatori effettuano:
la moltiplicazione *
la divisione /
il modulo %


Quando si effettua la divisione tra interi il risultato viene troncato all'intero. L'operatore di modulo divide il primo operando per il secondo e restituisce il resto, entrambi gli operandi devono essere interi ed il segno del risultato è lo stesso del quoziente.

3.2.3.4 Operatori di uguaglianza

Questi operatori effettuano il test di uguaglianza o non-uguaglianza e sono:
uguaglianza = =
non-uguaglianza ! =


Effettuano le necessarie conversioni aritmetiche sui loro operandi e restituiscono un valore di tipo intero. Questo valore è uguale a 1 se il test è positivo, se il test è negativo il valore è 0.
È possibile effettuare il test anche su puntatori o indirizzi di memoria, il test di uguaglianza è considerato positivo quando i puntatori o gli indirizzi individuano la medesima locazione di memoria. Consideriamo il seguente esempio:

001 Dichiarazione di un array di interi, due puntatori ad intero e una variabile intera di controllo.

002 Assegnazione ai puntatori pa e pb dell'indirizzo del primo elemento dell'array. Test di uguaglianza ed assegnamento del risultato alla variabile di controllo chk e restituzione di entrambi gli indirizzi e della variabile di controllo. Notiamo che in questo esempio gli rvalue dell'array non contengono alcun valore, ma la cosa non riveste importanza in quanto effettuiamo il controllo solamente sugli lvalue dell'array attraverso i puntatori pa e pb.

003 Incremento del puntatore pb, test di uguaglianza ed assegnamento del risultato alla variabile di controllo chk e restituzione di entrambi gli indirizzi e della variabile di controllo. Notiamo che in questo caso il test è negativo ed alla variabile chk viene assegnato il valore 0.

Il programma produce il seguente output su un sistema Unix:

chk: 1, pa: 7fffbb2c, pb: 7fffbb2c
chk: 0, pa: 7fffbb2c, pb: 7fffbb30

 ed il seguente su un sistema MS-DOS:

chk: 1, pa: 0FFA, pb: 0FFA
chk: 0, pa: 0FFA, pb: 0FFC

3.2.3.5 Operatori relazionali

Gli operatori relazionali sono:
minore di <
maggiore di >
minore o uguale a <=
maggiore o uguale a >=


Questi operatori effettuano il confronto tra due operandi e producono come risultato un int che assume il valore da 1 o 0 se la relazione è rispettivamente vera o falsa. Inoltre possono essere raggruppati secondo la regola da sinistra a destra, nel caso a
Possiamo confrontare anche puntatori o indirizzi di memoria, in questo caso viene valutata la posizione relativa dell'indirizzo, un puntatore ad un oggetto ad un indirizzo basso è minore di un puntatore ad un oggetto ad un indirizzo alto. Vediamo con un esempio l'uso degli operatori relazionali:

001 Dichiarazione di un array di interi, due puntatori ad intero e una variabile intera di controllo.

002 Assegnazione dei valori all'array.

003 Assegnazione ai puntatori pa e pb dell'indirizzo di a[0]. Incremento di pb.

004 Confronto se il valore di a[1] è maggiore del valore di a[2], assegnazione del risultato a chk e restituzione del valore di chk.

005 Confronto se l'indirizzo di a[1] è maggiore dell'indirizzo di a[2], assegnazione del risultato a chk e restituzione del valore di chk.

006 Confronto se il puntatore pa è minore del puntatore pb, assegnazione del risultato a chk e restituzione del valore di chk.

007 Confronto se il valore di a[2] è maggiore del valore di a[1], confronto di questo risultato (in questo caso 0) con il valore attuale di chk (in questo caso 1, vedi punto 006), assegnazione del risultato a chk e restituzione del valore di chk.

Il programma effettua il seguente output:

a[1] > a[2] - chk: 1
&a[1] > &a[2] - chk: 0
pa > pb - chk: 1
a[2] > a[1] < chk - chk: 1

3.2.3.6 Operatori logici

Gli operatori logici sono:
AND logico & &
OR logico | |


Questi operatori valutano gli operandi da sinistra a destra e producono come risultato un intero che può essere 1 o 0 se la condizione logica verificata é rispettivamente vera o falsa. Prendiamo per esempio la espressione AND logica:

espr1 && espr2

 se entrambe le espressioni espr1 e espr2, che sono operandi per &&, sono risolte in valori diversi da 0 il risultato sarà 1, se uno dei due operandi é 0 il risultato sarà 0. L'espressione espr2 non viene valutata se espr1 é risolta con 0.

Nel caso dell'OR logico:

espr1 || espr2

 se almeno una delle due le espressioni non é 0 il risultato sarà 1 mentre sarà 0 se entrambe le espressioni sono risolte con valore 0. L'espressione espr2 non viene valutata se espr1 é risolta con 1.

Consideriamo il seguente esempio:

001 Dichiarazione ed assegnazione delle variabili.

002 Restituzione delle variabili a e b.

003 AND logico sulle espressioni "a < b" e "b < a + 1" ed assegnazione del valore risolto alla variabile chk. Restituzione della variabile chk.

004 OR logico sulle espressioni "a > b" e "b = = a + 1" ed assegnazione del valore risolto alla variabile chk. Restituzione della variabile chk.

Il programma produce il seguente output:

a: 3
b: 4
a < b & & b < a + 1: 0
a > b | | b = = a + 1 : 1

3.2.3.7 Operatori orientati al bit

Gli operatori orientati al bit, bitwise secondo la terminologia anglosassone, sono i seguenti Operatori orientati ai bit
NOT ~ (unario)
AND & (binario)
XOR ^ (binario)
OR | (binario)


Questi operatori possono essere usati solamente con operandi interi di qualsiasi dimensione e, diversamente dagli operatori logici vengono valutati sempre entrambi gli operandi, naturalmente nel caso degli operatori binari.

L'operatore NOT bitwise ~ compie il complemento logico bit per bit, quindi se il bit è abbassato, ovvero è 0, questo viene alzato, ovvero portato a 1.
L'operatore AND bitwise & ha come risultato il bit alzato se il corrispondente bit di entrambi gli operandi è alzato, altrimenti il bit risultante è abbassato.
L'operatore OR bitwise | ha come risultato il bit alzato se il corrispondente bit di ameno uno degli operandi è alzato, solo quando entrambi i bit sono abbassati il bit risultante è abbassato.

L'operatore XOR bitwise ^ ha come risultato il bit alzato se il corrispondente bit di ameno uno degli operandi è alzato, quando i bit corrispondenti degli operandi sono entrambi alzati o sono entrambi abbassati il bit risultante sarà abbassato.
Come abbiamo visto le regole che determinano i risultati degli operatori bitwise sono quelle, ovviamente, dell'algebra di Boole, ma vediamo con un programma di esempio il funzionamento di questi operatori. Il programma contiene una funzione che visualizza lo stato dei singoli bit con i caratteri 0 e 1, per la sua piena comprensione sarà forse utile leggere ancora alcune pagine di questo libro:

Consideriamo il seguente programma:

001 Test dell'operatore NOT bitwise, si assegna alla variabile a il valore di -7, viene visualizzato il valore e lo stato dei singoli bit in due byte.

002 Si effettua il NOT bitwise, si assegna il risultato alla variabile c e si visualizza valore e stato dei bit.

003 Test dell'operatore AND bitwise, si assegna alla variabile a il valore di 22 e alla variabile b il valore di 39. Si visualizzano i valori e lo stato dei singoli bit.

004 Si effettua l'AND bitwise, si assegna il risultato alla variabile c e si visualizza valore e stato dei bit.

005 Test dell'operatore OR bitwise, si assegna alla variabile a il valore di 9 e alla variabile b il valore di 97. Si visualizzano i valori e lo stato dei singoli bit.

006 Si effettua l'OR bitwise, si assegna il risultato alla variabile c e si visualizza valore e stato dei bit.

007 Test dell'operatore XOR bitwise, si assegna alla variabile a il valore di 37 e alla variabile b il valore di 43. Si visualizzano i valori e lo stato dei singoli bit.

008 Si effettua l'XOR bitwise, si assegna il risultato alla variabile c e si visualizza valore e stato dei bit.

009 Funzione che effettua la visualizzazione dello stato dei singoli bit in due byte.

Il programma produce il seguente output:

Operatore ~ NOT bitwise
a: -7 - bits: 11111111 11111001
c: 6 - bits: 00000000 00000110


Operatore & AND bitwise
a: 22 - bits: 00000000 00010110
b: 39 - bits: 00000000 00100111
c: 6 - bits: 00000000 00000110


Operatore | OR bitwise
a: 9 - bits: 00000000 00001001
b: 97 - bits: 00000000 01100001
c: 105 - bits: 00000000 01101001


Operatore ^ XOR bitwise
a: 37 - bits: 00000000 00100101
b: 43 - bits: 00000000 00101011
c: 14 - bits: 00000000 00001110

3.2.4 Operatori unari

Gli operatori unari sono quelli che ammettono un solo operando e con questo formano una espressione unaria. Come possiamo dedurre dalle precedenti tavole tutti gli operatori unari godono di uguale precedenza e sono associati da destra a sinistra.

Gli operatori unari sono raggruppabili nelle seguenti categorie: Degli operatori appartenenti alle ultime due categorie abbiamo già trattato in precedenza, per l'operatore di cast nel capitolo 2.12, relativamente ai tipi di dati, e per l'operatore di NOT bitwise nel capitolo 3.2.3.6, relativamente agli operatori orientati al bit. Ci si perdoni l'aver inserito un operatore unario assieme agli operatori binari, ma abbiamo ritenuto più chiaro trattare unitariamente tutti gli operatori orientati al bit.

3.2.4.1 Negativi logico ed aritmetico

Il negativo logico effettua sull'espressione un operazione Booleana che produce come risultato il valore intero 1 se l'espressione-operando viene risolta con 0, il risultato è 0 se quest'ultima viene risolta con un valore diverso da 0. Naturalmente la negazione logica trova la sua più comune applicazione nei test condizionali che verranno trattati nel capitolo successivo.

Il negativo aritmetico provoca una conversione del valore della variabile sottraendo ad essa il suo valore doppio, secondo le normali regole aritmetiche Il seguente esempio illustra la sintassi di questi operatori:

Il programma produce il seguente output:

chk : 0
y : -3
chk : 1

3.2.4.2 Operatori incrementali e decrementali

Questi operatori che effettuano l'incremento o il decremento di una unità della variabile-operando possono farlo sia prima dell'utilizzo, sia dopo l'utilizzo della variabile stessa secondo che l'operatore venga posto prima o dopo l'identificatore della variabile.

Sintassi degli operatori incrementali e decrementali
Operatore Descrizione
+ + x pre-incremento di x
x + + post-incremento di x
- - x pre-decremento di x
x - - post-decremento di x

Nel caso x sia una variabile di tipo intero o in virgola mobile l'incremento è di una unità aritmetica, nel caso x sia un puntatore l'incremento è della dimensione della variabile a cui il puntatore riferisce. Per un puntatore a char incremento di 1, per un puntatore a short int incremento di 2, per un puntatore a double incremento di 8, ecc.

Gli operatori di incremento e decremento sono spesso usati in modo nidificato all'interno di chiamate a funzione, il seguente esempio mostra gli effetti di questi operatori ed il loro uso nidificato all'interno della funzione printf():

Il programma produce il seguente output su un sistema Unix:

Incremento rvalue

x: 3 c: D - valori iniziali

x: 3 c: D - post-incremento
x: 4 c: E - istruzione success.

x: 5 c: F - pre-incremento
x: 5 c: F - istruzione success.

Incremento lvalue

px: 7fffbb34 pc: 7fffbb2c - valori iniziali

px: 7fffbb34 pc: 7fffbb2c - post-incremento
px: 7fffbb36 pc: 7fffbb2d - istruzione succ.

px: 7fffbb34 pc: 7fffbb2c - pre-decremento
px: 7fffbb34 pc: 7fffbb2c - istruzione succ.

 ed il seguente su un sistema MS-DOS:

x: 3 c: D - valori iniziali

x: 3 c: D - post-incremento
x: 4 c: E - istruzione success.

x: 5 c: F - pre-incremento
x: 5 c: F - istruzione success.

Incremento lvalue

px: 0FFE pc: 0FF9 - valori iniziali
px: 0FFE pc: 0FF9 - post-incremento
px: 1000 pc: 0FFA - istruzione succ.

px: 0FFE pc: 0FF9 - pre-decremento
px: 0FFE pc: 0FF9 - istruzione succ.

3.2.4.3 Operatori indirizzo ed indirezione

Questi operatori, che del resto sono già stati largamente usati negli esempi precedenti, meritano alcune concise precisazioni.

L'operatore di indirizzo & risolve l'espressione nell'lvalue dell'identificatore per permetterne l'assegnazione ad un puntatore. Nell'esempio precedente infatti abbiamo utilizzato le seguenti assegnazioni:
br> px = &x;
pc = &c;

 Ricordiamo che nessun puntatore può essere usato prima che punti a qualcosa di valido. L'operatore di indirezione * risolve l'espressione nell'oggetto puntato dal puntatore o da una espressione risolta in un indirizzo.

Consideriamo il seguente esempio:

001 Dichiarazione di un array di int e di un puntatore a int.

002 Assegnazione al puntatore dell'indirizzo del terzo elemento dell'array e dei valori 3, 6, 9, ai singoli elementi dell'array.

003 Output del puntatore px (indirizzo di x[2]).

004 Output del valore di x[2] e del suo indirizzo per mezzo del puntatore px e post decremento dello stesso.

005 Output del valore di x[1] e del suo indirizzo per mezzo del puntatore px e post decremento dello stesso.

006 Output del valore di x[0] e del suo indirizzo per mezzo del puntatore px.

007 Valore attuale di px

Il programma produce il seguente output su un sistema Unix:

px : 7fffbb34
x[2] : 9 - 7fffbb34
x[1] : 6 - 7fffbb30
x[0] : 3 - 7fffbb2c
px : 7fffbb2c

 ed il seguente su un sistema MS-DOS:

px : 0FFE
x[2] : 6 - 0FFE
x[1] : 3 - 0FFC
x[0] : 3 - 0FFA
px : 0FFA

 Notiamo come l'operatore di indirezione utilizzato nelle istruzioni 004, 005, 006 consenta di accedere al valore delle variabili x[2], x[1] e x[0].

3.2.4.4 Operatore sizeof

Per calcolare la dimensione in byte di un oggetto esiste l'operatore sizeof, apparentemente la sua forma sintattica potrebbe essere confusa con una chiamata a funzione, ma come nel caso del cast si tratta di un reale operatore.

La forma generale è la seguente :

sizeof(tipo);

 Vediamone alcune applicazioni nel seguente esempio:

Il programma determina il seguente output:

p : 4
a : 8
b : 24
c : 40
s.a: 4
s.b: 4
s.c: 16
s : 24

 che indica la dimensione ricavata dall'operatore sizeof, nidificato nella funzione printf() per ogni elemento dichiarato.

L'ultima istruzione, sizeof(s), ricava la dimensione totale della struttura s. Alcune volte con le strutture potreste notare che la dimensione totale è superiore alla somma delle dimensioni dei singoli membri, questo può dipendere dall'ottimizzazione che il compilatore esegue per aderire all'architettura del sistema.

3.2.5 Operatori ternari

In C, in effetti, esiste un solo operatore ternario ed è un operatore condizionale che assume la forma seguente:

e1 ? e2 : e3;

 dove e1, e2, e3 sono espressioni. Se l'espressione e1 viene risolta con un valore diverso da 0 allora viene valutata l'espressione e2 altrimenti viene valutata l'espressione e3.

Vediamo ora un semplice esempio:

Il programma produce il seguente output:

0 - falso
3 - vero

 Il programma utilizza tre variabili a, f, t rispettivamente un int e due array di char, per la definizione dei due array si è utilizzata la funzione di libreria strcpy che effettua la copia di una costante stringa in un array di char, abbiamo già utilizzato questa funzione nel capitolo 2.8.2.

Notiamo che questa funzione richiede l'inclusione del header file string.h che contiene i prototipi delle funzioni di manipolazione delle stringhe di caratteri. Si veda il capitolo dedicato al preprocessore per maggiori dettagli.

Successivamente alla assegnazione ai due array delle stringhe "falso" e "vero" assegnamo alla variabile a il valore 0 mediante l'espressione -3 + 3, quindi chiamiamo la funzione printf() a cui passiamo due argomenti: la variabile a e l'espressione condizionale a ? t : f; dato che il valore di a è 0 l'espressione condizionale sarà risolta in f ed è questa la stringa che viene restituita in output.

La seguente istruzione assegna alla variabile a il valore 3; ora nuovamente troviamo una chiamata a printf(), identica alla precedente, però questa volta l'espressione condizionale sarà risolta in t.

3.2.6 Operatore virgola

Quando due o più espressioni sono separate dall'operatore virgola , vengono valutate da sinistra a destra, vengono abbandonati, dopo la valutazione, i risultati delle espressioni a sinistra e viene mantenuto il risultato dell'ultima espressione a destra.

Consideriamo il seguente esempio:

001 Da sinistra: alle variabile 'a' e 'b' viene assegnato il valore 1, alla variabile 'b' viene sommato il valore 2; otterremo per le due variabili i seguenti valori: a = 1 e b = 3.

002 Da sinistra: alle variabile 'a' e 'b' viene assegnato il valore 1, alla variabile 'b' viene sommato il valore 2 ed il risultato viene riassegnato alla variabile 'b', a quest'ultimo valore viene sottratto 1 ed il risultato riassegnato alla variabile 'b'; otterremo per le due variabili i seguenti valori: a = 1 e b = 2.

L'esecuzione del programma infatti produce il seguente output:

a:1 b:3
a:1 b:2

 Notiamo come, nel caso di più espressioni separate da virgola, non vengano mai persi i risultati delle espressioni intermedie.

3.2.7 Espressioni di assegnazione

Abbiamo detto precedentemente che l'operatore di assegnazione può essere a sua volta un'espressione quando viene usato in combinazione con alcuni altri operatori.
Queste espressioni sono chiamate comunemente forme abbreviate e sono spesso utilizzate per ottenere espressioni piu` concise e sono costituite dall'operatore di assegnazione = in combinazione con un operatore binario.

La forma generale, per esempio nel caso di addizione è:

e1 += e2;

 che equivale a:

e1 = e1 + e2;

 Vediamo ora un breve programma di esempio:

All'inizio abbiamo assegnato alle variabili intere a e b i valori di 3 e 5, abbiamo dichiarato le variabili c e d come double per poter effettuare una divisione senza troncare il valore e abbiamo prodotto l'output di a e b.

Vediamo ora le espressioni di assegnazione:

001 Sommiamo 'a' con 'b' e assegnamo il risultato ad 'a', l'operazione equivalente e` 3 + 5 = 8 = 'a'.

002 Moltiplichiamo 'a' con 'b' ed assegnamo il risultato ad 'a', l'operazione equivalente e` 8 * 5 = 40 = 'a'.

003 Sottraiamo 'b' da 'a' ed assegnamo il risultato ad 'a', l'operazione equivalente e` 40 - 5 = 35 = 'a'.

004 Assegnamo i valori di 'a' e 'b' alle variabili 'c' e 'd', notiamo l'uso dell'operatore di cast per effettuare la conversione di tipo.

005 Dividiamo 'd' con 'c' ed assegnamo il risultato a 'd', l'operazione equivalente e` 5 / 35 = 0.142857 = 'd'.

L'output prodotto dal programma sarà infatti:

a: 3
b: 5
a += b : 8
a *= b : 40
a -= b : 35
d /= c : 0.142857

Torna all'indice