====== Esercitazione ======

Tipi di dato .\\
**ATTENZIONE: per le informazioni relative ai tipi di dato fare riferimento a {{ :fisica:informatica:201718:esercitazioni:005-linguaggio_c--tipididato.pdf |questi lucidi}}.
**


===== Esercizio 1: Lunghezza dei tipi in C =====
Data la seguente lista non esaustiva, dei nomi accettati per i tipi di base in C: 
<code>
char
unsigned char
short
unsigned short
int
unsigned int
long
unsigned long
long long
float
double
long double 
</code>
utilzzate la funzione ''sizeof()'' per stampare la lunghezza in byte di ciascun tipo nella lista estendendo il seguente codice
<code>
#include <stdio.h>

int main (void) {
  printf("il tipo int e' lungo %lu.\n",sizeof(int));
  return 0;
}
</code>
Verificate inoltre che lo la richiesta dello standard venga rispettata, cioe':
<code>
sizeof(short) <= sizeof (int) <= sizeof(long)
</code>

===== Esercizio 2: L'intervallo di rappresentazione dei tipi ''int''=====
Nel file ''limits.h'' sono contenute le macro che forniscono i massimi e minimi numeri rappresentabli da ogni tipo C, in particolare:
<code>
SHRT_MIN SHRT_MAX
INT_MIN INT_MAX
LONG_MIN LONG_MAX
</code>
sono i limiti inferiori e superiori per gli interi con segno dei vari tipi base. Scrivere un programma C che li stampa e verificare che corrispondono ai valori dell'intervallo di rappresentabilita'
<code>
(-2^{n-1}, 2^{n-1} -1)
</code>
dove ''n'' e' il numero di bit utilizzati da ciascuna rappresentazione. Stampare il valore degli estremi per i vari tipi interi e verificare la formula sopra.

===== Esercizio 3: I tipi ''unsigned'' =====
Il tipo unsigned del C utilizza tutte le rappresentazioni disponibili per rappresentare i Naturali. 
Scrivere un programma C che legge un intero ''N'' senza segno da standard input e lo stampa sullo standard output in notazione decimale, ottale ed esadecimale utilizzando la funzione ''printf()'' (suggerimento: utilizzare la sezione 3 del manuale per ottenere informazioni sui segnapoosti %x %X %d %u e %o)



===== Esercizio 4: Codici ASCII =====
Scrivere un programma C che stampa i codici ASCII di tutte le lettere minuscole e maiuscole.

 
===== Esercizio 5: Trasformare in maiuscole =====
Scrivere un programma C che legge in input un carattere minuscolo e lo trasforma in un carattere maiuscolo. Controllare che il carattere letto sia effettivamente una lettera minuscola.

===== Esercizio 6: Esplorare i reali.... =====
I reali sono rappresentati all'interno del computer utilizzando mantissa ed esponente. 
''float.h'' e' il file che descrive la rappresentazione dei reali in una particolare implementazione C. Le principali costanti sono descritte 
[[http://www.tutorialspoint.com/c_standard_library/float_h.htm|qui]].

Scrivere un programma C che stampa i limiti di rappresentazione dei principali tipi reali ed alcune delle costanti di float.h relative alla lunghezza della rappresentazione (ad esempio la lunghezza della mantissa)

In ''float.h'' sono presenti anche le funzioni 
<code>
fpclassify(), isinf(), isnan()
</code>
a cosa servono ?

===== Esercizio 7: Conversioni implicite =====
Nei lucidi {{ :fisica:informatica:201718:esercitazioni:005-linguaggio_c--tipididato.pdf | su tipi di dato}} a pagina 28-32 sono riassunte le conversioni automatiche effettuate dal linguaggio C quando si trova a valutare un'espressione che contiene valori di tipi diversi. Leggetele attentamente e utilizzatele per spiegare i valori stampati dal seguente programma:
<code>
#include <stdio.h>

int main (void) {
double x, y=5.;
int a = 4;

x = 1/2;
printf("Primo valore: %lf\n", x); 

x = y/2;
printf("Secondo valore: %lf\n", x); 

x = a/2;
printf("Terzo valore: %lf\n", x); 

x = 1./2;
printf("Quarto valore: %lf\n", x); 

x = 1/(double)2;
printf("Quinto valore: %lf\n", x);
return 0;
}
</code>

===== Esercizio 8: Calcolo della radice quadrata ======
Dato un numero reale positivo //a// si consideri la sequenza dei numeri reali //x// definita da 
<code>
x[0] = 1
x[i+1] = 1/2*(x[i] + a/x[i])
</code>
si puo' dimostrare che ''x[i]'' tende alla radice quadrata di //a// per //i// che tende all'infinito.

Scrivere un programma che legga il valore di //a// da standard input e calcoli la radice quadrata di //a// utilizzando la sequenza. In particolare, si calcoli la sequenza fino a che ''x[i]'' non diventa uguale a ''x[i+1]'', il valore ottenuto e' l'approssimazione cercata per la radice quadrata di //a//.

Ad ogni ciclo, far stampare su standard output il numero dell'iterazione ''i'', il valore di ''x[i]'' ed il valore di ''a-x[i]*x[i]'' per controllare la convergenza.

===== Esercizio 9: Istogramma =====
Scrivere un programma C che legge dallo standard input una sequenza di caratteri (terminata da \n) e calcola l'istogramma dei caratteri 0 1 2 3 4 5 6 7 8 9 stampandolo su standard output alla fine della sequenza.


===== Esercizio 10: Parentesi bilanciate ? (avanzato) =====
Scrivere un programma C che legge dallo standard input una sequenza di caratteri (terminata da EOF -- per generare EOF basta usare la combinazione di tasti CONTROL-D) e verifica se

  * se il numero delle parentesi aperte e chiuse coincide e 
  * se la parentesi aperta precede sempre la parentesi chiusa. 

Ad esempio:
<code>
{lkshaj[nnnn()]}{}
</code>
e' una sequenza corretta, mentre
<code>
{lkshaj][nnnn()}{}
</code>
e' scorretta.

Utilizzare ''getchar()'' per leggere i caratteri uno ad uno, la funzione restituisce EOF quando lo stream e' finito (vedi ''man getchar''). 

Inserendo manualmente i caratteri EOF puo' essere generato utilizzando la combinazione di tasti CONTROL-D.

Quando il programma e' funzionante, verificare il bilanciamento delle parentesi del programma stesso utilizzando la redirezione. Ad esempio, se l'eseguibile relativo al mio programma si chiama ''checkpar'', e il sorgente si trova nel file checkpar.c, provare ad eseguire
<code>
bash$ ./checkpar < checkpar.c
</code>