Dopo aver preso confidenza con il piccolo/grande Raspberry Pi e, soprattutto, con il suo compilatore, questa volta approfondiremo alcuni aspetti fondamentali della programmazione. Con le istruzioni che daremo in questa puntata sarete in grado di realizzare programmi iterativi e algoritmi capaci di prendere delle decisioni. Si tratta di concetti presenti anche in altri linguaggi di programmazione. Il materiale studiato è propedeutico alla programmazione definitiva di sistemi che possono interagire anche con la porta di I/O, al fine di poter pilotare dispositivi elettrici ed elettronici di qualsiasi tipologia.
Introduzione
Nella scorsa puntata si è visto come realizzare un semplice programma che potesse "comunicare" con l'operatore. Abbiamo appreso le tecniche per visualizzare messaggi e risultati e studiato anche i metodi per consentire l'immissione di dati numerici da tastiera, dietro richiesta da parte del PC.
Questa volta faremo molto di più. Impareremo a creare un software più "usabile" e più dinamico, che sappia districarsi tra varie evenienze e condizioni. La funzione del programmatore, infatti, è quella di far prevedere alla propria creatura qualsiasi tipologia di fatto, in modo da essere sempre pronto con la giusta sequenza di codice operativo. Gli esempi, di difficoltà sempre crescente, consentiranno di muovere i primi passi con disinvoltura e cognizione di causa. Inoltre essi avranno un carattere "tendente" all'elettronica, proprio in vista di futuri sviluppi del settore.
Ripetere comodamente un algoritmo
Abbiamo già visto il significato e la funzione di una variabile. Si supponga, adesso, di voler visualizzare a video, una tabella (tabella 1), riportante i valori di tensione, corrente e potenza circolanti in un circuito. Tale tabella deve essere, ovviamente, generata dal computer.
| Tensione (Volt) | Corrente (Ampere) | Potenza (Watt) |
| 5 | 3 | 15 |
| 10 | 6 | 60 |
| 15 | 9 | 135 |
| 20 | 12 | 240 |
| 25 | 15 | 375 |
| 30 | 18 | 540 |
| 35 | 21 | 735 |
| 40 | 24 | 960 |
| 45 | 27 | 1215 |
| 50 | 30 | 1500 |
Tabella 1: Tensione, corrente e corrispondente potenza
I valori dei Volt e degli Ampere sono già noti a priori e, come si vede, incrementano di 5 in 5 e di 3 in 3 (per una nostra libera scelta). Il valore della potenza, invece, è calcolato sulla base degli altri due, secondo la nota formula della legge di Ohm:
W=V*I
Senza un opportuna gestione del problema, un programmatore sprovveduto scriverebbe un codice molto lungo, magari funzionante ma non funzionale ed ottimizzato. Si limiterebbe, infatti, a scrivere e determinare i calcoli, riga per riga, e visualizzarli. Ecco di seguito un esempio sbagliato di programma, assolutamente da non seguire.
#include <stdio.h>
int main() {
/*------Dichiarazione variabili-----*/
int volt,ampere,watt;
/*-----Primo calcolo------*/
volt=5;
ampere=3;
watt=volt*ampere;
printf("%2dV %2dA = %2dW\n",volt,ampere,watt);
/*-----Secondo calcolo------*/
volt=10;
ampere=6;
watt=volt*ampere;
printf("%2dV %2dA = %2dW\n",volt,ampere,watt);
/*-----Terzo calcolo------*/
volt=15;
ampere=9;
watt=volt*ampere;
printf("%2dV %2dA = %2dW\n",volt,ampere,watt);
/*-----Quarto calcolo------*/
volt=20;
ampere=12;
watt=volt*ampere;
printf("%2dV %2dA = %2dW\n",volt,ampere,watt);
/*-----Quinto calcolo------*/
volt=25;
ampere=15;
watt=volt*ampere;
printf("%2dV %2dA = %2dW\n",volt,ampere,watt);
/*-----Sesto calcolo------*/
volt=30;
ampere=18;
watt=volt*ampere;
printf("%2dV %2dA = %2dW\n",volt,ampere,watt);
/*-----Settimo calcolo------*/
volt=35;
ampere=21;
watt=volt*ampere;
printf("%2dV %2dA = %2dW\n",volt,ampere,watt);
/*-----Ottavo calcolo------*/
volt=40;
ampere=24;
watt=volt*ampere;
printf("%2dV %2dA = %2dW\n",volt,ampere,watt);
/*-----Nono calcolo------*/
volt=45;
ampere=27;
watt=volt*ampere;
printf("%2dV %2dA = %2dW\n",volt,ampere,watt);
/*-----Decimo calcolo------*/
volt=50;
ampere=30;
watt=volt*ampere;
printf("%2dV %2dA = %2dW\n",volt,ampere,watt);
return 0;
}
Come si vede, si tratta di uno stupidissimo programma che, di volta in volta, assegna alle rispettive variabili i corretti valori di tensione e di corrente, calcola la relativa potenza e stampa i risultati. Funziona perfettamente, ma è scritto [...]
ATTENZIONE: quello che hai appena letto è solo un estratto, l'Articolo Tecnico completo è composto da ben 3292 parole ed è riservato agli ABBONATI. Con l'Abbonamento avrai anche accesso a tutti gli altri Articoli Tecnici che potrai leggere in formato PDF per un anno. ABBONATI ORA, è semplice e sicuro.
Un semplice esempio ma molto utile per affrontare i prossimi codici che Giovanni ci metterà a disposizione. Una serie sempre molto interessante!
Salve, ho fatto l’esercizio finale, ecco il mio listato:
#include
#include
int main(){
/*—-Dichiarazioni variabili—-*/
int f1, f2, prodotto, risposta, i;
int operazioni=5, n=0;
printf(“\n\n”);
/*—-Ciclo—-*/
for(i=1; i<=operazioni; i++){
f1=rand() % 10;
f2=rand() % 10;
prodotto=f1*f2;
printf(" Quanto fa %d * %d ? ",f1,f2);
scanf("%d",&risposta);
if(risposta==prodotto)
n++;
}
/*—-Stampa punteggio—-*/
printf("\n Totale risposte esatte: %d\n\n ",n);
return 0;
}
Scusate, ho fatto copia e incolla del mio listato, ma le prime due rigne si sono stampate incomplete:
#include
#include
Bravissimo Tony21.
Mancano solo gli “include” ma e’ PERFETTO.
CIao
Giovanni
Avevo provato una mia versione e ho provato questo. Ma non capiusco una cosa, Perchè i calcoli proposti sono sempre uguali e non cambiano esecuzione per esecuzione?
hai verificato che siano inglobati nel ciclo iterativo?
Per assicurare un buon “random” occorre anche cambiare
la generazione del seme, usando la funzione srand(time(NULL));
da chiamarsi solo una volta nel programma.
Grazie Giovanni,
Non capisco perchè scrivendo nel commento “include stdio.h” e “include stdlib.h” mi posta solo “include”, forse il problema sono le freccine che hanno un comando particolare nella pagina web? Comunque l’importante è che il listato rende l’idea del suo funzionamento.
Ciao
Si, penso proprio di si.
I browse si confondono, essendo i simboli “maggiore” e “minore” facenti parte del linguaggio HTML.
CIao.
Bella serie di articoli, anche se ho usato il C/C++, fa sempre bene un ripasso! 😉
Nell’esempio di codice per calcolare l’occupazione di memoria dei diversi tipi di variabile, il compilatore potrebbe lamentarsi (mediante un warning) del fatto che il formato %d utilizzato per scrivere il numero di byte non è di tipo compatibile col tipo restituito dalla funzione sizeof() (long unsigned int).
Sul mio sistema “long unsigned int” occupa 8 byte mentre “int” 4 byte.
Un sistema per ovviare all’inconveniente (cioè evitare un warning) è usare un typecast, es.:
printf(“Char %d\n”, (int)sizeof(v1));
Magari il tema verrà affrontato in una delle prossime puntate.
Grazie della puntualizzazione. Tratteremo sempre le varie tematiche del C e tra un paio di mesi circa inizierà il corso avanzato di C.
Grazie,
salve, ho appena inziato il corso C. ecco la mia esecuzione dell’esercizio.
#include
#include
int main () {
/*———–Variabili————–*/
int risu,risp,k;
int totale=0;
unsigned int a,b;
/*———–Ripetizione ciclo——*/
for(k=1;k<=5;k++) {
a=rand() % 10 ;
b=rand() % 10 ;
/*————Calcolo—————*/
risu=a*b;
/*———–Richiesta di Dati——*/
printf("\n\n\n");
printf("Quanto fa: %d x %d = ?",a,b);
scanf("%d",&risp);
/*———controlla risposta——-*/
if (risp==risu)
totale++;
}
/*————Display risposte——–*/
printf("Risposte esatte %d\n\n",totale);
return 0;
}
Ciao Zeno.
Complimenti, bravo.
Ho provato il tuo codice, funziona perfettamente!!!!.
Ricorda di rispettare sempre i rientri, anche se credo che sia un problema delll’HTML.
Bravo
Grazie mille Giovanni. hai ragione, devo stare piu’ attento ai rientri, l’html non c’entra, e’ colpa mia!