Gli operatori sono utilizzati per manipolare delle informazioni all’interno di un’ espressione.
Un’ espressione è un insieme di elementi combinati tra loro per eseguire un determinato calcolo.
I primi tre operatori che analizzeremo sono: unari, binari e ternari.
Gli operatori unari influenzano un singolo valore o variabile e comprendono i segni:
- + somma
- - sottrazione
- ++ incremento
- – decremento
- ! negazione logica
- ~ complemento a bit
L’operatore ~ di complemento a bit, inverte la rappresentazione binaria di un valore cioè tutti i bit a 1 si trasformano in 0 e i bit a 0 si trasformano in 1. Più avanti spiegherò anche questo concetto.
Gli operatori binari sono quegli operatori che funzionano con due operandi. Per esempio, una espressione binaria potrebbe essere la seguente: somma=num1+num2;
essa fa uso dell’operatore di addizione che opera su due operandi, num1 e num2.
Gli operatori binari si dividono ulteriormente in aritmetici, relazionali, logici e di assegnamento.
Gli operatori ternari sono gli operatori più complessi e fanno uso di tre variabili.
Il C# comprende un solo operatore ternario, l’operatore condizionale. Ha la seguente sintassi:
var = condizione ? istruzione1 : istruzione2;
in base al risultato (true o false) del test eseguito dalla condizione, verrà assegnato alla variabile var il risultato dell’istruzione1 (true) oppure dell’istruzione2 (false).
Di quest’ultimo tipo di operatore lo spiegherò con maggiore dettaglio quando parlerò delle istruzioni condizionali.
Operatori aritmetici.
Durante la scrittura di un programma, gli operatori aritmetici sono gli operatori più usati. Gli operatori aritmetici di C#, sono quelli che fanno parte della stragrande maggioranza dei linguaggi di programmazione moderni. Questi sono:
- + addizione: c=a+b;
- - sottrazione: c=a-b;
- * moltiplicazione: c=a*b;
- / divisione: c=a/b;
- % resto intero: c=a%b;
Di questi operatori ne faremo largo uso ma c’è una tipologia di operatori, se vogliamo un po’ strani, che sono gli operatori aritmetici composti.
Questo tipo di operatori composti, ci consentono di scrivere velocemente una operazione aritmetica che riguarda l’aggiunta di un valore ad una variabile. Per esempio se volete incrementare il valore della variabile x di 3 unità, potete scrivere x=x+3; . Però ora potete anche usare l’operatore composto += in questo modo: x+=3; che esegue la medesima operazione. Tutti gli operatori aritmetici visti prima, possono essere usati per effettuare una operazione composta.
Vediamo un piccolo esempio:
1 using System;
2 class incremento
3 {
4 static void Main()
5 {
6 // dichiaro una variabile con assegnazione diretta
7 byte num1=20;
8 // stampo il suo valore
9 Console.WriteLine("\nLa variabile num1 contiene: "+num1);
10 // incremento di 5 il suo contenuto
11 num1+=5;
12 // stampo il suo nuovo valore
13 Console.WriteLine("La variabile num1 adesso contiene: "+num1);
14 Console.ReadLine();
15 }
16 }
Sicuramente avrete già notato delle novità, ve le vengo subito a spiegare:
riga 9 e 13: +num1 si chiama concatenamento, ossia che aggiunge un valore (nel nostro caso della variabile) ad un altro (il testo),
ad esempio:
string nome = ("mario"); //dichiaro la prima variabile
string cognome = (”rossi”); //dichiaro la seconda variabile
//concatenazione di nome e cognome
Console.WriteLine(”il mio nome è “+nome + ” ” +cognome);
Console.Readline();
riga 9: \n, con questo segno diciamo semplicemente di andare a capo e non verrà stampata a video, ne esistono molte di queste funzionalità per avere maggior ordine all’interno della Console, piano piano ne useremo diverse.
Operatori aritmetici unari.
Gli operatori di cui si è parlato, erano fondamentalmente di tipo binario. In C# (come anche in Java) esistono due tipi di operatori aritmetici particolari di tipo unario cioè agiscono su un solo valore. Sono l’operatore di incremento ++ e di decremento – . Per esempio l’istruzione ++x;
incrementa la variabile x di una unità (viene chiamato operatore prefisso). Avremmo potuto scrivere tranquillamente x=x+1; ma l’operatore unario ++x; , come si vede, è più pratico e veloce. Ovviamente all’operatore di incremento si oppone quello di decremento, –x; .
Possono essere usati anche facendo seguire il segno dell’operazione alla variabile, per esempio x++;
(viene chiamato operatore postfisso). Però qui le cose cambiano.
con x=10, assegnerà ad y il valore di x incrementato di una unità, cioè 11. In pratica l’istruzione incrementerà prima la variabile x e successivamente la assegnerà ad y. Se invece avessi scritto così: y=x++;
Facciamo un esempio. L’istruzione y=++x;
la variabile y non avrebbe il valore 11 ma 10. La spiegazione sta nel fatto che con l’operatore postfisso, l’incremento viene effettuato dopo l’assegnazione, cioè ad y viene prima assegnato il valore di x e successivamente avviene l’incremento. Una tale situazione deve essere presa in seria considerazione perché potrebbe alterare il risultato di una operazione. Gli operatori unari, quindi, devono essere utilizzati con molta attenzione e cognizione di causa.
Operatori relazionali.
Durante la scrittura di un programma, capita spessissimo di dover eseguire un blocco di codice al posto di un altro in base al risultato della valutazione di una condizione. Nella valutazione di una condizione, di solito compaiono due valori che saranno confrontati.
Gli operatori relazionali vengo utilizzati appunto per effettuare questi confronti. Questi sono gli operatori relazionali:
- > maggiore di
- < minore di
- == uguale a
- != diverso da
- >= maggiore o uguale a
- <= minore o uguale a
Il risultato di questi confronti è un valore booleano (vero o falso), per esempio:
- 5>3 vero
- 3> 6 falso
- 4==4 vero
- 2!=2 falso
Sta diventando tutto un po’ più complesso piano piano, ma vi assicuro che man mano che utilizzeremo tutti questi operatori sarà chiarissima la loro funzionalità!
