RaspberryItaly Community Italiana
In questa terza lezione, proviamo ad usare i tipi visti nella lezione precedente come operandi.
Gli operatori sono algebrici, logici e booleani, andiamo a scoprirli.
Sommario
- Operatori aritmetici
- Operatori logici
- Operatori booleani
- Precedenza degli operatori
- Sommario
- Esercizi
1 Operatori aritmetici
Vediamo prima gli operatori binari (perché lavorano con 2 operandi).
Si tratta delle 4 operazioni aritmetiche più il modulo:
- somma (+)
- differenza (–)
- moltiplicazione (*)
- divisione (/)
- modulo o resto della divisione (%)
Spendiamo qualche parola solo sul modulo (meno noto).
Se divido 10 per 2 ottengo 5 senza resto, ma se eseguo 5/3 ottengo 1 con il resto di 2: quindi
- 10%2 = 0
- 5%3 = 2
Interi e floating point possono partecipare entrambi nelle operazioni ed il risultato sarà una grandezza del tipo definito dalle seguenti regole:
- int op int = int
- float op int = float
- double op int = double
- float op float = float
- float op double = double
- double op double = double
Il modulo, come già detto, lavora solo con interi e produce interi.
Proviamo ad usarne alcuni in esempio3_1.c
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
/*********************** esempio3_1.c Esempio di uso degli operatori algebrici arkkimede marzo 2021 ***********************/ #include <stdio.h> int main() { int i = 3, j=4; float f=4.2, g=9.1; double d = 12.5, e = 15.7; printf("Somma tra due interi: %d + %d = %d\n",i,j,i+j); // Si noti la divisione tra 2 interi che produce un intero printf("Divisione tra interi: %d / %d = %d\n",j,i,j/i); printf("Modulo: %d %% %d = %d\n",j,i,j%i); // Notate una notazione alternativa per il formato sui float // Si richiede solo 2 cifre dopo la virgola printf("Moltiplicazione tra intero e float: %d * %f = %.2f\n",i,f,i*f); printf("Divisione tra float: %.2f / %.2f = %.2f\n",f,g,f/g); printf("Sottrazione tra intero e double: %d - %lf = %.2lf\n",i,g,i-g); printf("Moltiplicazione tra float e double: %f * %lf = %lf\n",f,e,f*e); printf("Somma tra double: %lf + %lf = %lf\n",d,e,d+e); return 0; } /* Output Somma tra due interi: 3 + 4 = 7 Divisione tra interi: 4 / 3 = 1 Modulo: 4 % 3 = 1 Moltiplicazione tra intero e float: 3 * 4.200000 = 12.60 Divisione tra float: 4.20 / 9.10 = 0.46 Sottrazione tra intero e double: 3 - 9.100000 = -6.10 Moltiplicazione tra float e double: 4.200000 * 15.700000 = 65.939997 Somma tra double: 12.500000 + 15.700000 = 28.200000 */ |
In sostanza il C omogenizza le grandezze prima di fare le operazioni.
Converte la grandezza meno significativa in quella più significativa: gli interi sono trasformati in float o double ed i float in double.
Per qualsiasi motivo, può accadere che questa regola (implicita) a noi non vada bene.
E’ allora sempre possibile l’operazione di cast, in cui si decide il tipo di risultato che interessa.
Nell’esempio seguente lunghezza viene trasformata in int: (int)lunghezza
In esempio3_2.c vediamo l’operazione di cast all’opera
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
/************************ esempio3_2.c Esempio di uso della funzione cast applicata all'uscita di una operazione arkkimede marzo 2021 ************************/ #include <stdio.h> int main() { int i = 3, j=4; float f=4.2; double d = 12.5, e = 15.7; printf("+ tra int => in double: %d + %d = %lf\n",i,j,(double)(i+j)); printf("* tra int e float => in int: %d * %f = %d\n",i,f,(int)(i*f)); printf("+ tra double => in float: %lf + %lf = %f\n",d,e,(float)(d+e)); return 0; } /* Output + tra int => in double: 3 + 4 = 7.000000 * tra int e float => in int: 3 * 4.200000 = 12 + tra double => in float: 12.500000 + 15.700000 = 28.200001 */ |
Esaminiamo adesso gli operatori aritmetici unari ossia che lavorano con un solo operando. Si applicano solo agli interi e sono ++ e – –. Il primo incrementa la grandezza intera di un unità il secondo la decrementa (sempre di un’unità). Possono essere usati anche in espressioni matematiche mettendoli prima o dopo la variabile.
Nel primo caso la variabile prima è incrementata di un’unità poi viene valutata l’espressione, nel secondo caso prima si valuta l’espressione e poi si incrementa la variabile come in esempio3_3.c:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
/****************************** esempio3_3.c In questo codice vedremo gli operatori unari all'opera arkkimede marzo 2021 ******************************/ #include <stdio.h> int main() { int i; i = 10; printf("i prima della valutazione espressione = %d\n",i); printf("Espressione (i++)*5 : %d \n",(i++)*5); printf("i dopo aver valutato l'espressione = %d\n",i); printf("-----------------\n"); i = 10; printf("i prima della valutazione dell'espressione = %d\n",i); printf("Espressione (++i)*5 : %d \n",(++i)*5); printf("i dopo aver valutato l'espressione = %d\n",i); return 0; } /* Output: i prima della valutazione espressione = 10 Espressione (i++)*5 : 50 i dopo aver valutato l'espressione = 11 ----------------- i prima della valutazione dell'espressione = 10 Espressione (++i)*5 : 55 i dopo aver valutato l'espressione = 11 */ |
Ovviamente nessuno obbliga ad usare questi operatori in funzioni. Va sempre bene prima applicare l’operatore e poi valutare l’espressione (o viceversa a seconda dei casi).
L’ultimo aspetto relativo agli operatori algebrici riguarda una notazione compatta per tutte le espressioni del tipo:
a = a + b
w = w – z
d = d * e
g = g / h
che possono anche essere riscritte come:
a += b
w -= z
d *= e
g /= h
Con questa notazione i++ si può anche scrivere i += 1
2 Operatori logici
Si tratta di operatori che generano espressioni che possono essere vere o false. A titolo di esempio 10 > 5 è un’espressione il cui valore è vero. Gli operatori logici sono i seguenti:
- == uguale a
- != diverso da
- > maggiore di
- >= maggiore o uguale di
- < minore di
- <= minore o uguale di
di questi operatori logici non si daranno esempi di programmazione: ritorneranno protagonisti nelle espressioni condizionali (if).
3 Operatori booleani
Sebbene il C, a differenza di altri linguaggi non preveda il tipo booleano, gli operatori booleani esistono e si usano per concatenare espressioni logiche. Di questi operatori binari ne esistono svariati ma qui saranno esaminati i più comunemente usati nella programmazione: and e or.
A livello di programmazione sono rappresentati con i seguenti simboli && e ||
Uniscono due espressioni logiche ed il loro funzionamento è il seguente:
and
a && b = c
a=falso b=falso c=falso
a=falso b=vero c=falso
a=vero b=falso c=falso
a=vero b=vero c=vero
or
a || b = c
a=falso b=falso c=falso
a=falso b=vero c=vero
a=vero b=falso c=vero
a=vero b=vero c=vero
Quindi l’and è vero se entrambi gli operandi sono veri mentre l’or è vero se uno solo degli operandi è vero.
Esiste anche un operatore booleano unario che è il not (a livello di programmazione !) con la seguente tabella della verità:
not
!a = b
a=vero b=falso
a=falso b=vero
4 Precedenza degli operatori
Volendo valutare un’espressione, bisogna sempre fare attenzione alla precedenza degli operatori.
Una panoramica la possiamo trovare per esempio qui. Ma proviamo a vedere un esempio.
Se voglio calcolare, la seguente espressione y = 4 + 5 * 7 – 8 / 2, dobbiamo ricordare che la moltiplicazione e divisione verranno valutate prima e successivamente somma e sottrazione.
Nel dubbio abbondiamo di parentesi (sempre tonde) che risolvono tutti i nostri dubbi
Questo è l’ultimo argomento della terza lezione
5 Sommario
- Gli operatori algebrici binari sono le 4 operazioni aritmetiche e la funzione resto
- Possono essere usati con interi e floating point: il risultato sarà del tipo più rappresentativo
- L’operatore di cast può comunque trasformare qualsiasi grandezza in un tipo a piacere
- Esistono due operatori algebrici unari ossia — e ++: decrementano o incrementano di una unità un intero
- Il C prevede anche operatori logici binari: diverso da, uguale a, maggiore o uguale di, minore o uguale di
- Il risultato degli operatori logici è vero o falso, sebbene come variabili tali espressioni non siano presenti (vedremo il motivo nella prossima lezione)
- Esistono operatori booleani che operano su grandezze logiche. I più usati sono and e or: and è vero se e solo se entrambi gli operandi sono veri, or è vero se solo uno degli operandi è vero
- Esiste l’operatore unario booleano not che converte un vero in falso e viceversa
- Infine ricordiamo che tra gli operatori esiste una precedenza. Per risolvere ogni dubbio usiamo le parentesi tonde.
6 Esercizi
- Provare ad usare gli operatori algebrici binari ed unari cercando di prevedere quale sarà il risultato, stampandolo con il suo proprio formato
- Verificare infine l’operazione di cast e trasformare espressioni intere in float o double e queste in intere
Arrivederci
Qui il forum di supporto al corso.
Se vuoi restare aggiornato, seguici anche sui nostri social: Facebook, Twitter, Youtube
Se vuoi anche trovare prodotti e accessori Raspberry Pi in offerta, seguici anche su Telegram !!
|
1 |
