RaspberryItaly Community Italiana
Dunque come va?
Nel forum c’è una discussione dedicata a questo corso.
Tutte le impressioni, domande, chiarimenti e, perché no, critiche… Sono bene accette.
Passiamo adesso alla quarta lezione dove useremo gli operatori logici che abbiamo visto nella lezione precedente.
Sommario
1 Indentazione
Si tratta di quella particolare formattazione del codice che mette in evidenza un blocco rispetto all’intero sorgente.
Questa modalità è stata utilizzata sin dall’inizio per le funzioni main che abbiamo visto fino ad ora.
Infatti l’intero corpo della funzione, rispetto alle parentesi graffe che la delimitano, è spostato a destra di 3 o 4 spazi. Anche qui si entra nel gusto personale circa il numero di spazi da inserire nella indentazione.
E’ bene precisare però che tale modo di scrivere il codice, ne aumenta solo la leggibilità ma dal punto di vista del compilatore non ha alcun effetto (a differenza per esempio di quanto avviene in Python).
Tale modalità verrà ampiamente usata nel seguito.
2 if
Si tratta delle istruzioni condizionali ossia eseguite o meno sulla base di una condizione, vera o falsa.
Vediamo esempio4_1.c in cui appare un primo caso di uso:
|
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 |
/***************************** esempio4_1.c Primo esempio di uso di if arkkimede marzo 2021 *****************************/ #include <stdio.h> int main() { int i=10; int j=20; if (i == 10) { printf("La variabile i è uguale a 10\n"); } if (j > 30) printf("La vatiabile j è maggiore di 30\n"); return 0; } /**************************** Output: La variabile i è uguale a 10 ****************************/ |
Osserviamo per prima cosa l’indentazione e poi l’uso o meno delle parentesi.
A questo proposito nel caso di un’istruzione sola, le parentesi possono essere opzionali.
Se invece il blocco da eseguire prevede più istruzioni, le parentesi sono obbligatorie, altrimenti è eseguita solo la prima istruzione.
Si veda esempio4_2.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 |
/**************************************** esempio4_2.c Caso di blocco racchioso tra parentesi o solo indentato arkkimede marzo 2021 ****************************************/ #include <stdio.h> int main() { int i=10; if (i != 10) printf("Istruzione 1: La variabile i è diversa a 10\n"); printf("Istruzione 2\n"); printf("Istruzione 3\n"); printf("Istruzione 4\n\n\n"); if (i == 10) { printf("Istruzione a: La variabile i è uguale a 10\n"); printf("Istruzione b\n"); printf("Istruzione c\n"); printf("Istruzione d\n"); } return 0; } /**************************** Output: Istruzione 2 Istruzione 3 Istruzione 4 Istruzione a: La variabile i è uguale a 10 Istruzione b Istruzione c Istruzione d ****************************/ |
Nel primo if la condizione ha effetto solo sulla prima riga (infatti non viene stampata), nel secondo, tutto il blocco racchiuso tra graffe è eseguito.
Un caso più articolato è quello in cui se la condizione è vera si esegue un blocco di codice, se è falsa se ne esegue un altro esempio4_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 |
/***************************** esempio4_3.c Caso if else arkkimede marzo 2021 *****************************/ #include <stdio.h> int main() { float temperatura = 33.7; if (temperatura < 22.) { printf("La temperatura è gradevole\n"); printf("Non fa troppo caldo o troppo freddo\n"); } else { printf("La temperatura è decisamente alta\n"); printf("Speriamo si abbassi un po'"); } return 0; } /**************************** Output: La temperatura è decisamente alta Speriamo si abbassi un po' ****************************/ |
Quindi è stata posta una soglia che separa il caldo dal moderato.
Volendo però è possibile avere più condizioni da esplorare ed allora si ottiene:
|
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 46 47 48 49 |
/***************************** esempio4_4.c Caso if else if else if ... else arkkimede marzo 2021 *****************************/ #include <stdio.h> #define FREDDO 0. #define FREDDINO 10. #define TEMPERATO 20. #define CALDO 30. int main() { float temperatura = 33.7; if (temperatura <= FREDDO) { printf("Fa freddo\n"); } else if (temperatura > FREDDO && temperatura <= FREDDINO) { printf("Fa freddino\n"); } else if (temperatura > FREDDINO && temperatura <= TEMPERATO) { printf("La temperatura è moderata\n"); } else if (temperatura > TEMPERATO && temperatura <= CALDO) { printf("Fa caldo\n"); } else { printf("Fa caldissimo\n"); } return 0; } /**************************** Output: Fa caldissimo ****************************/ |
Nell’esempio4_4.c sono anche state introdotte le direttive al preprocessore, che prima di compilare il codice sostituiscono a FREDDO il valore 0., a FREDDINO 10. etc. E’ stato anche usato l’operatore booleano and che unisce due espressioni logiche.
Questo è un caso a scelta multipla in cui ogni condizione definisce un suo percorso.
Nella lezione scorsa avevamo detto che in C non sono definite le variabili True e False come per esempio in Python.
Tramite esempio4_5.c cerchiamo di capire come mai:
|
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 |
/***************************** esempio4_5.c Definizione di true e false arkkimede marzo 2021 *****************************/ #include <stdio.h> int main() { if (0) printf("0 è vero\n"); else printf("0 è falso\n"); if (1) printf("1 è vero\n"); else printf("1 è falso\n"); if (-1) printf("-1 è vero\n"); else printf("-1 è falso\n"); if(12.56) printf("12.56 è vero\n"); else printf("12.56 è falso\n"); if(-448.136) printf("-448.136 è vero\n"); else printf("448.136 è falso\n"); return 0; } /**************************** Output: 0 è falso 1 è vero -1 è vero 12.56 è vero -448.136 è vero ****************************/ |
Nel C solo il valore zero coincide con il falso, mentre qualsiasi valore differente da zero (positivo, negativo, intero, floating point) è vero.
In queste condizioni, risulta allora difficile definire la variabili True (vero) a causa di questa moltitudine di possibili valori che la variabile potrebbe assumere.
3 switch
Rispetto al caso precedente, questa istruzione consente di selezionare una opzione tra quelle disponibili, ma la scelta è fatta sulla base di una grandezza costante che tipicamente può essere un carattere o un intero. Vediamo un esempio
|
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 |
/***************************** esempio4_6.c L'istruzione switch arkkimede marzo 2021 *****************************/ #include <stdio.h> int main() { char operatore = '+'; switch(operatore) { case '+': printf("Selezionata l'addizione\n"); break; case '-': printf("Selezionata la sottrazione\n"); break; case '*': printf("Selezionata la moltiplicazione\n"); break; case '/': printf("Selezionata la divisione\n"); break; default: printf("Operazione non conosciuta\n"); } return 0; } /**************************** Output: Selezionata l'addizione ****************************/ |
Quindi le varie possibilità di scelta sono rappresentate dai vari case e vi è anche la possibilità di inserire un default (se lo si desidera), che raccoglie tutte le altre opzioni non contemplate precedentemente. Altra peculiarità è la presenza del break che interrompe il case.
Se nell’esempio precedente si voleva solo indicare le operazioni commutative:
|
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 |
/***************************** esempio4_7.c Ruolo del break nello switch arkkimede marzo 2021 *****************************/ #include <stdio.h> int main() { char operatore = '-'; switch(operatore) { case '+': case '*': printf("Operazione commutativa\n"); break; case '-': case '/': printf("Operazione non commutativa\n"); } return 0; } /**************************** Output: Operazione non commutativa ****************************/ |
In altre parole i primi due case sono collassati nello stesso (ed analogamente per gli ultimi due).
4 for
Questa istruzione permette di effettuare un certo numero di iterazioni di un blocco di codice mediante un indice che si incrementa (o decrementa) nel corso dell’esecuzione.
La sintassi è la seguente:
|
1 2 3 4 5 6 7 8 |
for( i=valore_iniziale; i<valore_finale; i = i + incremento) { blocco di codice da ripetere } for( i=valore_iniziale; i>valore_finale; i = i - decremento) { blocco di codice da ripetere } |
Supponiamo di voler stampare i numeri da 1 a 10:
|
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 |
/***************************** esempio4_8.c for arkkimede marzo 2021 *****************************/ #include <stdio.h> int main() { for(int i=1; i<=10; i++) { printf("%2d\n",i); } return 0; } /**************************** Output: 1 2 3 4 5 6 7 8 9 10 ****************************/ |
Si noti la possibilità di dichiarare la variabile nel loop. Quella i esiste ed ha valore solo tra le due parentesi graffe del for. Se la medesima variabile fosse stata usata al di fuori del for, il compilatore avrebbe segnalato un errore. Stiamo sfiorando il così detto scope di una variabile, ossia dove è dichiarata ed esiste e dove no.
I cicli possono essere anche annidati. A titolo di esempio proviamo a stampare la Tavola Pitagorica con i numeri da 1 a 10:
|
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 |
/***************************** esempio4_9.c for annidati: calcolo della Tavola Pitagorica arkkimede marzo 2021 *****************************/ #include <stdio.h> int main() { int i,j; for(i=1; i<=10; i++) { for(j=1; j<=10; j++) { printf("%4d ",i*j); } printf("\n"); } return 0; } /**************************** Output: 1 2 3 4 5 6 7 8 9 10 2 4 6 8 10 12 14 16 18 20 3 6 9 12 15 18 21 24 27 30 4 8 12 16 20 24 28 32 36 40 5 10 15 20 25 30 35 40 45 50 6 12 18 24 30 36 42 48 54 60 7 14 21 28 35 42 49 56 63 70 8 16 24 32 40 48 56 64 72 80 9 18 27 36 45 54 63 72 81 90 10 20 30 40 50 60 70 80 90 100 ****************************/ |
Qui la dichiarazione degli indici è normale, l’uscita è stata formattata su 4 caratteri, in modo da avere le cifre allineate e si noti il carattere ‘\n’ di “a capo”, stampato solo alla fine di ogni riga.
Come detto quando abbiamo presentato il for, gli incrementi del’indice non devono essere necessariamente di uno, e si può anche decrementare:
|
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 |
/***************************** esempio4_10.c for: altri usi arkkimede marzo 2021 *****************************/ #include <stdio.h> int main() { int i,j; for(i=50; i>0; i-=5) { printf("%3d\n",i); } return 0; } /**************************** Output: 50 45 40 35 30 25 20 15 10 5 ****************************/ |
Potrebbe accadere che per qualche motivo, vogliamo saltare un ciclo o che dopo un certo numero di iterazioni vogliamo fermare il ciclo, in questi compiti ci vengono in aiuto le istruzioni continue e break.
Supponiamo di voler stampare i numeri da 0 a 10 ma non far apparire il 3 ed il 5:
|
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 |
/***************************** esempio4_11.c for e continue arkkimede marzo 2021 *****************************/ #include <stdio.h> int main() { for(int i=0; i<=10; i++) { if(i==3 || i==5) { continue; } else { printf("%2d\n",i); } } return 0; } /**************************** Output: 0 1 2 4 6 7 8 9 10 ****************************/ |
Qualora invece si inizializzi il codice per fare mille iterazioni, ma dopo 10 lo si voglia fermare:
|
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 |
/***************************** esempio4_12.c for e break arkkimede marzo 2021 *****************************/ #include <stdio.h> #include <unistd.h> #define ITER_STOP 10 int main() { for(int i=0; i<=1000; i++) { if(i==ITER_STOP) { break; } else { printf("%2d\r",i); sleep(1); fflush(stdout); } } return 0; } /**************************** Output: 9 ****************************/ |
In questo esempio ci sono alcune novità:
- Il ‘\n’ sostituito con ‘\r’.
Questo ha l’effetto di riportare il cursore a capo ma non lo fa avanzare nella riga seguente, causando l’effetto di veder girare il numero su se stesso. - sleep(1): necessario rallentare la stampa a video (1 secondo tra un numero e l’altro) altrimenti non si vede niente, solo il numero finale (#include <unistd.h>).
- Svuotare la memoria video (fflush(stdout)) per evitare il buffering delle uscite e vedere tutte le uscite man mano che sono disponibili.
5 while
Anche con questa istruzione si realizza un loop. La sintassi è la seguente:
|
1 2 3 4 |
while(espressione logica vera) { blocco di codice da ripetere } |
vediamo subito un esempio:
|
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 |
/***************************** esempio4_13.c while arkkimede aprile 2021 *****************************/ #include <stdio.h> int main() { int i = 0; while(i<=5) { printf("i = %2d\n",i); i++; } return 0; } /**************************** Output: i = 0 i = 1 i = 2 i = 3 i = 4 i = 5 ****************************/ |
Un altro modo di usare il while e quello di usare una condizione sempre vera ed utilizzare il break per uscire dal ciclo:
|
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 |
/***************************** esempio4_14.c while(1) arkkimede aprile 2021 *****************************/ #include <stdio.h> int main() { int i = 0; while(1) // Espressione sempre vera { if(i<=5) { printf("i = %2d\n",i); } else { break; } i++; } return 0; } /**************************** Output: i = 0 i = 1 i = 2 i = 3 i = 4 i = 5 ****************************/ |
Ovviamente anche nel while, se si vuol saltare qualche ciclo senza eseguire il blocco di codice, si può usare l’istruzione continue.
6 do while
Questa istruzione è molto simile al while. La sintassi è:
|
1 2 3 4 5 |
do { blocco di codice da ripetere } while(espressione logica vera) |
Rispetto alla precedente ha una caratteristica: il blocco tra parentesi è eseguito almeno una volta.
|
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 |
/***************************** esempio4_15.c do while arkkimede aprile 2021 *****************************/ #include <stdio.h> int main() { int i = 0; do { printf("i = %2d\n",i); i++; } while(i<=5); return 0; } /**************************** Output: i = 0 i = 1 i = 2 i = 3 i = 4 i = 5 ****************************/ |
7 Riassunto
- In questa lezione abbiamo visto le istruzioni condizionali ed i cicli.
- L’istruzione if consente di valutare o meno un blocco di codice sulla base di un’espressione logica.
- Può essere semplice, a due alternative (if-else), a più alternative (if-else if-else if-….-else).
- Lo switch invece esegue un particolare blocco di codice sulla base di una grandezza intera o carattere
- Per quanto riguarda i cicli invece, abbiamo iniziato con il for
- Sulla basa di un indice di cui se ne definisce l’estremo inferiore, quello superiore ed il suo incremento, si esegue un blocco di codice
- continue consente di saltare una o più iterazioni, break interrompe il ciclo
- while e do while eseguono il blocco di codice sulla base di una espressione logica che deve risultare vera. Il secondo esegue almeno una volta tutto il blocco.
8 Esercizi
Questa settimana vogliamo fare qualcosa di diverso. In C esiste l’istruzione rand(), che lanciata ripetutamente produce dei numeri pseudo casuali. Questi sono definiti sulla base di un seme che inizializza la sequenza. L’istruzione che effettua questo è: srand(seme). E’ necessario includere stdlib.h (per ogni dettaglio consultate man 3 rand). La proposta allora di questa settimana è la seguente: Dopo aver inizializzato il generatore di numeri pseudo casuali con 100, calcolare la somma dei primi 10 numeri pari e dei primi 8 numeri dispari generati da rand(). Come aiuto, si propone lo scheletro del codice a cui aggiungere lo svolgimento:
|
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 |
/*********************** esercizio.c arkkimede aprile 2021 ***********************/ #include <stdio.h> #include <stdlib.h> #define NUMERO_DI_PARI 10 #define NUMERO_DI_DISPARI 8 int main() { int nPari = 0; int nDispari = 0; long long int sommaPari = 0; long long int sommaDispari = 0; int estratto; srand(100); ...svolgimento... printf("La somma dei primi %d numeri pari è %lld\n",NUMERO_DI_PARI,sommaPari); printf("La somma dei primi %d numeri dispari è %lld\n",NUMERO_DI_DISPARI,sommaDispari); return 0; } /*************************** Output: La somma dei primi 10 numeri pari è 9794103776 La somma dei primi 8 numeri dispari è 7113881004 ***************************/ |
La prossima settimana, prima della lezione, verrà riportato il risultato.
Anche per oggi abbiamo finito.
Per qualsiasi cosa scrivete pure sul forum e non dimenticate di seguirci sui nostri social: Facebook, Twitter, Youtube.
Se vuoi anche trovare prodotti e accessori Raspberry Pi in offerta, seguici anche su Telegram !!
