ERRATA CORRIGE

ERRATA CORRIGE
Pulizia del buffer di input: come fare?
(1) Dopo aver richiamato getchar() per prelevare un carattere dal buffer di input, inseriamo una seconda
chiamata a getchar(), senza assegnare il valore restituito ad alcuna variabile. Questa soluzione va bene nel
caso in cui l’utente abbia premuto un solo tasto (prima dell’ENTER), se non è così questa soluzione non
funziona correttamente
(2) Servirsi della funzione ricorsiva presentata alla fine della seconda settimana.
void SvuotaBuffer(void);
void SvuotaBuffer(void)
{
if(getchar()!=10)
{svuotabuffer();}
}
(3) Usare un costrutto iterativo per svolgere il medesimo compito
... istruzioni ...
while(getchar()!=10)
{;}
... ancora istruzioni ...
!
IMPORTANTE
!
Con il passare del tempo le indicazioni relative ai codici da implementare diventeranno via via meno dettagliate ....
Scrivere una funzione che accetta due parametri
di tipo intero e restituisce un valore di tipo intero.
La funzione deve sommare i due valori ricevuti
come parametro, calcolare l’ottava potenza della
somma e e restituire il valore così ottenuto.
Scrivere una funzione che calcola l’ottava potenza
della somma di due numeri.
Abituatevi a preparare un diagramma, PRIMA di iniziare a scrivere il codice, che vi serva per organizzare le idee
e capire quali operazioni svolgere per ottenere il risultato.
valore1
valore2
+
for( ... ; ... ; ... )
7 volte
return
NOTA: da qui in avanti cercate di inserire prototipo ed implementazione delle funzioni in un file separato (ad
esempio funzioni.h) e di richiamare tale file (usando la direttiva #include). Durante il corso useremo questo file per
esaminare ulteriormente il processo di compilazione.
Gli array
Gli array (o vettori) sono degli insiemi di variabili (tutte dello stesso tipo). L’insieme possiede un nome e ciascun
elemento dell’insieme è identificato da un indice progressivo che parte dal valore 0.
Gli elementi sono posizionati in memoria in modo tale da essere uno adiacente all’altro.
#include <stdio.h>
Questo valore deve essere NOTO al momento della compilazione -> costante o MACRO
int main()
{int i;
int gruppo[50]; // ecco la dichiarazione di un array formato da 50 interi
// se ci sono 50 elementi, l’indice può arrivare solo fino a 49
gruppo[6] = 90; // assegno un valore al settimo elemento
gruppo[45]=23 + gruppo[6]; // assegno un valore al 46-esimo elemento basandomi sul valore del settimo
printf(“Ecco il settimo elemento dell’array: %d\n”,gruppo[6]); // visualizzo il valore di un elemento
gruppo[54]=2; // ERRORE !! l’indice non può superare il valore 49 !!!
// assegniamo un valore a tutti gli elementi dell’array
for(i=0;i<50;i++)
{gruppo[i] = 4 + i*2;}
// visualizziamo il valore di tutti gli elementi dell’array
for(i=0;i<50;i++)
{printf(“Ecco il valore dell’elemento num. %d: %d\n”,i,gruppo[i]);}
}
Inizializziamo un array di interi usando dei numeri casuali ...
#include <stdio.h>
#include “funzioni.h”
int main()
{int i, array[60]; // dichiaro l’array
i=0;
while(i<50)
{array[i] = IntCasuale(97,122);
// un intero compreso tra 97 e 122 rappresenta il codice ASCII di una lettera minuscola
printf(“Ecco il numero casuale: %d / ed il corrispondente carattere: %c\n”,array[i],array[i]);
i++;
}
return 0;}
Lasciamo inizializzare l’array all’utente ...
#include <stdio.h>
#include “funzioni.h”
int main()
{int i;
char array[200]; // stiamo larghi, nel caso l’utente sia prolisso ...
i=0;
printf(“Inserisci tanti caratteri! “);
while(i<200) // al massimo l’array può contenere 200 caratteri
{array[i] = getchar(); // prelevo un carattere
if(array[i]!=10)
{i++;}
else
{break;}
}
i++; // devo individuare l’indice del primo elemento non ancora inizializzato
for( ; i<200 ; i++) // inizializzo a 0 i rimanenti (se ve ne sono)
array[i]=0;
return 0;}
Esercizi proposti
(1) Definire ed implementare una funzione che riceva come parametro un valore di tipo char e restituisca un
valore di tipo intero. La funzione deve controllare il codice ASCII del carattere che riceve come parametro: se il
carattere e’ una lettera maiuscola deve restituire 1, altrimenti 0.
(2) Definire ed implementare una funzione che riceva come parametro un valore di tipo char e restituisca un
valore di tipo intero. La funzione deve controllare il codice ASCII del carattere che riceve come parametro: se il
carattere e’ una lettera minuscola deve restituire 1, altrimenti 0.
(3) Scrivere un programma in cui si dichiari un array di 100 caratteri. Chiedere all’utente di inserire (tanti, ma meno
di 90) caratteri mediante la tastiera. Utilizzando un ciclo while() prelevare tutti i caratteri del buffer, compreso
il terminatore, ed inserirli nell’array di char precedentemente dichiarato. Fatto questo, mediante un ciclo for,
scorrere l’array di caratteri; ogni volta che si incontra una lettera minuscola, trasformarla nella corrispondente
maiuscola, ogni volta che si incontra una lettera maiuscola, trasformarla nella corrispondente minuscola.
Servirsi delle funzioni definite ai punti (1) e (2). Fatto questo visualizzare il risultato.
(4) Partendo dal programma precedente, servendosi di un ciclo while(), scorrere tutto l’array di caratteri e contare
quante lettere maiuscole e quante lettere minuscole siano presenti. NOTA: nell’espressione di continuazione
del ciclo while() DEVE essere presente un elemento dell’array.
(5) Partendo dal programma precedente, servendosi di un ciclo for(), scorrere tutto l’array di caratteri e contare
quante volte ciascuna lettera minuscola compaia. Per fare questo, dichiarare un array di 26 int (tanti quante
sono le lettere dell’alfabeto), ogni elemento dell’array deve essere inizialmente posto uguale a 0. Ogni
elemento dovrà poi contenere il numero di occorrenze di ciascuna lettera all’interno del gruppo di caratteri
inseriti dall’utente. Nell’implementare questa parte NON servirsi di controlli (ad esempio usando if()) e
NEMMENO del costrutto switch-case.