Tra le seguenti istruzioni di input è presente una priva di errori mentre le altre presentano ognuna un errore. Sapresti identificare quella corretta e trovare gli errori presenti nelle altre?
scanf(“%d, k”); scanf(%d, k); scanf(“%d, &k); Scanf(“%d, &k); scanf(%d, “k”); scanf(%”d”, $k);
Il seguente programma C non usa l’istruzione if in ma- niera ottimale; inoltre presenta degli errori e non è scrit- to secondo le regole dell’indentazione. Interpreta il pro- gramma e prova a impostarlo in maniera più efficiente.
#include <stdio.h> int k; main( ) { printf(“Inserisci un numero ”); scanf(“%d”, &k); if(k==5) printf(“\nNumero = 5 \n”); k++;
printf(“Il valore di k e\’ %d\n”, k);
printf(“Inserisci un numero “); scanf(“%d”, &k); if(k==5) { printf(“\nNumero = 5\n”); k++; }
printf(“Il valore di k e\’ %d\n”, k);
system(“PAUSE”);
}
Il seguente programma C presenta degli errori e non è scritto secondo le regole dell’indentazione. Interpreta il programma e prova a impostarlo in maniera corretta.
#include <stdio> int a; main { printf(“Inserisci un numero ”); scanf(“%d”, &x); if (x=3);
printf(“Numero uguale a tre”)
system(PAUSE) } 3. 2. f e d c b a
1. Il seguente programma C presenta degli errori e non è
scritto secondo le regole dell’indentazione. Interpreta il programma e prova a impostarlo in maniera corretta.
#include <stdio.h>; int h; main( ) { printf(“Inserisci un numero ”); scanf(“%d”, &x); if(h=3);
printf(Numero uguale a tre);
x+;
else
printf(Numero diverso da tre);
system(PAUSA)
}
Enuncia il testo del problema relativo al seguente pro- gramma C: #include <stdio.h> int a, i, t; float r; main() { t = 0; i = 0;
printf (“Numeri da inserire: ”);
scanf(“%d”,&a); while (a >= 0) { i++; t += a; r = t/i;
printf (“La media attuale e\’: %.3f\n”, r);
printf (“Inserisci un numero: ”);
scanf(“%d”,&a);
}
printf (“La media finale e\’: %.3f\n”, r);
system(“PAUSE”);
}
Quale accorgimento puoi adottare per evitare di richiedere in input il dato sia fuori dal ciclo, sia all’interno di esso.
5. 4.
Training
PROVE APERTE PER LA VERIFICA DELLE ABILITÀ
Enuncia il testo del problema relativo al seguente pro- gramma C: #include <stdio.h> int a, t; main() { t = 0;
printf (“Inserisci un numero: “);
scanf(“%d”,&a);
while (a >= 0)
{
t += a;
printf(“Somma attuale =: %d\n”, t);
printf (“Inserisci un numero: ”);
scanf(“%d”,&a);
}
printf (“Somma finale =: %d\n”, t);
system(“PAUSE”);
}
Enuncia il testo del problema relativo al seguente pro- gramma C:
#include <stdio.h>
unsigned int x, y, z;
main()
{
scanf (“%u”, &x);
scanf (“%u”, &y);
scanf (“%u”, &z);
if ((x < y + z) && (y < x + z) && (z < x + y))
{
if (x == y && y == z)
{
printf (“Triangolo equilatero”);
}
else
{
if (x == y || y == z || x == z)
{
printf (“Triangolo isoscele”);
}
else
{
printf (“Triangolo scaleno”);
} } 7. 6. } else {
printf (“Non è un triangolo”);
}
system(“PAUSE”);
}
Ci sono delle righe che potevano essere omesse? Se sì, quali sono?
Quale valore assume la variabile z alla fine del pro- gramma? #include <stdio.h> char c; int z; main( ) { z=0; c=‘z’; for (; c < ‘a’; c++) z++; printf(“%d\n”, z); system(“PAUSE”); }
Enuncia il testo del problema relativo al seguente pro- gramma C: #include <stdlib.h> #include <stdio.h> int n, i; long a, b, c; main() { scanf(“%d”, &n); a = 1; b = 1; printf(“%ld %ld “, a, b);
for (i=2; i<n; i++)
{ c = a+b; printf(“%ld “, c); a = b; b = c; } system(“PAUSE”); } 9. 8.
Nel linguaggio C la componente principale dei codici è costituita da funzioni. Per poter simulare le procedure (che non restituiscono alcun valore) è stato introdot- to il tipo void. Ricordiamo, comunque, che il tipo void o tipo indefinito è utilizza- to dal C ogni volta che il valore di ritorno di una funzione non deve essere preso in considerazione. In altri termini, nel linguaggio C le procedure sono funzioni che restituiscono un void. Possiamo riassumere il processo di costruzione e uso di una funzione nelle seguenti tre fasi.
1. Definizione della funzione, cioè scrittura dell’elenco delle operazioni da essa svolte. La definizione specifica nell’ordine il tipo di valore restituito, il nome scelto dal programmatore (valgono le stesse regole viste per l’assegnazione dei nomi alle variabili) e, infine, l’elenco dei parametri. All’interno del corpo della funzione vengono inserite le dichiarazioni delle variabili della funzione e le istruzioni. La sintassi generale è quindi la seguente:
[<TipoRestituito>] <NomeFunzione>([<ElencoParametri>])
{
<Istruzioni>
[return [(]<Risultato>[)]]
}
Come si evince dalla sintassi, la specifica del <TipoRestituito> è opzionale: si assume, in sua assenza (per default), che il tipo restituito sia int, sebbene, per motivi di comprensibilità, sia sempre opportuno dichiarare esplicitamente il tipo. Nel caso in cui si desideri implementare una procedura occorre specifica- re come <TipoRestituito> il tipo void.
Anche <ElencoParametri>, che tratteremo più avanti, è opzionale: in sua as- senza occorre comunque far seguire il nome della funzione da una coppia di pa- rentesi tonde ( ), oppure inserire la parola chiave void all’interno delle parentesi tonde proprio per specificare che nessun parametro viene passato alla funzione. Ad esempio, void Funz() è equivalente a void Funz(void). Ricordiamo che Lo stan- dard C stabilisce che una funzione che non richiede parametri deve utilizzare l’identificatore void in modo esplicito, all’interno delle parentesi.
Nel caso in cui <ElencoParametri> sia presente, cioè se la funzione riceve pa- rametri, è necessario specificare il tipo, seguito dal nome del parametro, pro- prio come abbiamo fatto per dichiarare una variabile. Il tipo dei parametri è quello che abbiamo già studiato (int, float e così via). Se a una funzione si pas- sano più parametri, questi dovranno essere separati da una virgola.
Le definizioni di funzioni possono essere scritte in qualsiasi punto del pro- gramma: verranno eseguite in seguito alla chiamata, perciò non ha alcuna im- portanza dove siano fisicamente poste. Lo standard ANSI ha però fissato delle convenzioni secondo le quali è bene codificare le definizioni delle funzioni dopo il main.
Fra le istruzioni contenute nella definizione della funzione assume una parti- colare importanza return, utilizzata per restituire un valore al chiamante. La sintassi dell’istruzione prevede di specificare dopo la parola chiave return un valore costante, o una variabile, o un’espressione compatibile con il tipo resti- tuito dalla funzione. Ad esempio:
return 2; /* Restituisce il valore 2 – si può anche scrivere (2)*/
return x; /* Restituisce il valore contenuto nella variabile x */
return (a+b); /* Restituisce il risultato dell’espressione specificata */
return; /* Ritorna senza restituire alcun valore */
Non è importante che le definizioni di tutte le funzioni usate in un programma seguano l’ordine con cui sono chiamate, anche se, per motivi di chiarezza e leggibilità, è opportuno che sia così e che si segua l’ordine specificato in pre- cedenza. In ogni caso, la funzione con il nome main è eseguita per prima, in qualunque punto sia posta, e le funzioni sono eseguite nell’ordine in cui ven- gono chiamate.
Le funzioni
2. Dichiarazione del prototipodella funzione. Si tratta di ripetere all’inizio del programma, prima della definizione del main, l’intestazione delle funzioni de- finite in seguito. In pratica, si riscrive quanto specificato nella prima riga della definizione della funzione, includendo però un punto e virgola alla fine. I pro- totipi sono stati introdotti per consentire al compilatore un maggiore controllo sui tipi di parametri: conoscendoli in anticipo, infatti, all’atto della chiamata è possibile stabilire se i parametri passati sono congruenti con quelli attesi. Nella costruzione di programmi complessi capita di utilizzare molte funzioni. In questo caso le funzioni sono raccolte in librerie e i rispettivi prototipi sono rag- gruppati nei file di intestazione (o file header). Gli header sono file di testo che hanno estensione .h.
3. Chiamata della funzione. Consiste semplicemente nell’indicare, nel punto in cui occorre utilizzare l’elaborazione fornita dalla funzione, il nome della fun- zione stessa accompagnato dall’elenco dei parametri da trasmettere. Il pro- gramma chiamante può utilizzare il valore restituito dalla funzione: in tal caso il nome della funzione figurerà, ad esempio, in un’espressione. Il chiamante può trascurare il valore restituito anche se non è di tipo void: è sufficiente uti- lizzare la funzione senza assegnare il valore da questa restituito.
Giunti a questo punto del nostro percorso, è doveroso ricordare che anche il main è una funzione ed è proprio questo il motivo della presenza della coppia di parentesi tonde dopo la parola main. È una funzione speciale, poiché viene eseguita per prima all’avvio del programma. L’istruzione return può essere pre- sente anche nella funzione main, in tal caso il valore viene restituito diretta- mente al sistema operativo, che è il programma chiamante della funzione. Da questo momento, quindi, nei successivi esercizi sarà indicato il tipo int prima di main, per indicare il tipo del valore restituito, e alla fine del main verrà indica- ta l’istruzione return seguita dal valore 0, il modo più comune per indicare la ter- minazione di un programma che non ha rilevato errori durante l’esecuzione.
Vediamo ora un esempio che mostra un prototipo e una funzione in un program- ma:
dati in input due numeri interi, fornire in output il loro prodotto
.#include <stdio.h>
double Moltiplica(); /* questo e’ il prototipo della funzione */
int x, y;
int main( )
{
printf(“Inserire un numero intero “ );
scanf(“%d”, &x);
printf(“\nInserire un altro numero intero “ );
scanf(“%d”, &y);
printf(“Il prodotto e\’ %5.0f\n “, Moltiplica()); /* chiamata della funzione */
system(“PAUSE”);
return 0;
}
double Moltiplica() /* questa è l’intestazione della funzione */
{
/* questo e’ l’inizio del corpo della funzione */
return (x * y);
} /* questa e’ la fine del corpo della funzione */
Non è superfluo far notare che in questo programma la funzione è totalmente inu- tile e può solo moltiplicare interi. L’abbiamo inserita unicamente per mostrare come si costruisce una funzione.