1. HelloWorld. Scrivere con un editor di testi a propria scelta (vi, Emacs, ecc.) il codice sorgente del programma HelloWorld.c visto a lezione. Il programma deve stampare in output il testo "Hello, world!" e terminare con codice di ritorno 0.

   Compilare il programma usando il comando (da riga di comando) gcc -o HelloWorld HelloWorld.c (gcc è il compilatore C del progetto GNU, in assoluto il più diffuso al mondo; l'opzione -o indica in che file mettere l'eseguibile risultante) e verificare che funzioni come atteso.

2. Echo. Ripetere l'esercizio precedente scrivendo il programma Echo.c (che stampa i propri argomenti di riga di comando sull'output, uno per ogni riga, preceduto dal proprio numero d'ordine) visto a lezione. Ci si ricordi di includere il file di intestazione stdio.h per accedere alla funzione di libreria printf().

   Si modifichi poi il programma definendo una macro FORMATO al posto della stringa di formato usata nella funzione printf(), e si usi la macro nella chiamata a printf().

3. Uso dei file .h. Si sposti la definizione della macro FORMATO in un file formato.h, e si includa questo file all'interno del programma principale echo.c. Verificare che la compilazione produce lo stesso effetto che nel caso precedente.

4. Fasi della compilazione. Il compilatore gcc normalmente effettua l'intero processo di compilazione, da codice sorgente C ad eseguibile. Tuttavia, è possibile interrompere l'elaborazione in punti intermedi, ed osservare i risultati. In particolare:
   • l'opzione -c termina il processo prima di invocare il linker, lasciando nella directory di lavoro il file .o corrispondente al file .c compilato.
   • l'opzione -E termina il proceso prima di invocare il compilatore, lasciando nella directory di lavoro il file .c risultante dal pre-processor.
   Si esamini il file prodotto dal pre-processor (suggerimento: il vostro codice sarà in fondo al file), e si verifichi che passando al compilatore direttamente questo secondo file, si ottiene lo stesso programma ottenuto in precedenza.

   Avanzato ***: il comando objdump consente di vedere il contenuto dei file .o. Usate objdump -t file.o per vedere i simboli definiti all'interno del file, o objdump -d file.o per vedere il codice assembler compilato dal vostro codice C. Suggerimento: compilate il codice con gcc -g -c file.c e disassemblatelo con objdump -S file.o per vedere, riga per riga, come il vostro codice C viene trasformato in Assembler.

5. Uso della compilazione condizionale. Si modifichi il programma precedente inserendo delle direttive #if/#else/#endif in modo che, se è definito il simbolo DEBUG, vengano stampati gli argomenti, uno per riga, preceduti dal numero d'ordine (come in precedenza); altrimenti, vengano stampati solo gli argomenti, tutti su una riga e separati da spazi.

   Oltre che con #define, una macro come DEBUG può essere definita direttamente sulla riga di comando del compilatore con l'opzione -Dmacro=definizione o semplicemente -Dmacro. Si provi quindi a compilare il programma passando a gcc l'opzione -DDEBUG e senza e ad osservare il risultato.

   Si usi l'opzione -E di gcc per verificare quale codice viene passato al compilatore dal preprocessore nei due casi.

6. Uso di Eclipse. Si ripetano i primi due esercizi usando Eclipse come ambiente di sviluppo. Il docente effettuerà una dimostrazione su come creare un progetto C all'interno di Eclipse, come scrivere il codice sorgente, e come compilare ed eseguire il programma corrispondente.

   Avanzato *: si configurino le proprietà del progetto Eclipse per Echo in modo da definire o meno la macro DEBUG, come si è fatto con gcc -D.

Salvo ove diversamente indicato, gli esercizi seguenti possono essere risolti lavorando su Eclipse. Si suggerisce di creare un progetto distinto per ogni esercizio.

1. sizeof. L'operatore C sizeof consente di scoprire, a run-time, la dimensione in memoria di un tipo. Per esempio, sizeof(char) restituisce la dimensione, in byte, di un char. L'operatore accetta anche la variante sizeof(variabile) che restituisce la dimensione del tipo della variabile.
   Si scriva un programma C che stampi una tabella con i nomi dei tipi e la relativa dimensione. In particolare, si includano i seguenti tipi:
   • tutti i tipi base;
   • le rispettive varianti short e long (si verifichi anche il supporto per long long con vari tipi base);
   • gli stessi tipi con le varianti signed e unsigned;
   • i tipi puntatore corrispondenti;
   • array di varia dimensione dei tipi base.

   Avanzato *: si compili lo stesso programma con il gcc, in tre varianti: senza opzioni particolari, con l'opzione -m32, con l'opzione -m128bit-long-double, e con l'opzione -m96bit-long-double. Si confrontino i risultati nei diversi casi.

2. sizeof senza sizeof. Avanzato **: si trovi il modo di stampare una tabella analoga a quella precedente senza usare l'operatore sizeof. È accettabile limitare la tabella ai soli tipi "piccoli" (char, short, etc.).

3. strlen. La funzione di libreria strlen() prende come parametro una stringa, e restituisce la sua lunghezza. Per esempio, strlen("Ciao mamma!") restituisce 11.

   Si scriva una propria implementazione di questa funzione, chiamandola strlen2(). Si scriva poi una funzione main() che, per ciascuna delle stringhe passate sulla riga di comando, stampi la stringa, la sua lunghezza calcolata da strlen() e quella calcolata da strlen2(). Si verifichi che le due funzioni restituiscano lo stesso risultato.

4. Caratteri escape. Si scriva un programma che, usando a scelta strlen() o strlen2(), stampi la lunghezza delle seguenti stringhe:
   • "Ciao mamma!"
   • "test\n"
   • "test\\n"
   • "test\\\n"
   • "test\0test"
   • "test\\0test"
   Si commentino i risultati. Sono sempre quelli attesi?

5. Output di booleani. Si provi a stampare con printf() il valore di alcuni booleani, per esempio con printf(formato,1==1) o printf(formato,1==2). Quale pensate sia il formato più adatto? Come si possono interpretare i risultati?

6. Valore dei puntatori. Si scriva un programma C che contenga le seguenti dichiarazioni:

   int a=666;
int *b=&a;
int **c=&b;
char *s="Ciao mamma!";


   Il programma deve stampare, per ciascuna delle espressioni a, b, c, s, *b, *c, *s, **c, &a, &b, &c, &s, il testo dell'espressione e il suo valore numerico, usando una riga per ciascuna espressione. Si disegni (su carta) il diagramma dell'ambiente e della memoria corrispondente alle dichiarazioni in questione, usando gli indirizzi e i valori stampati dal programma. Si verifichi che, per ciascuna delle espressioni sopra indicate, la traccia della valutazione delle espressioni nel diagramma coincida con il valore effettivamente stampato dal programma.

7. Codifica ASCII. Si scriva una funzione C dumpASC() che, ricevuta come parametro una stringa, stampi a video i caratteri che la compongono, uno per riga, ciascuno seguito dal corrispondente codice ASCII. Si scriva poi un main() che chiami dumpASC() su ciascuno degli argomenti passati sulla riga di comando.

8. atoi. La funzione di libreria atoi() ("ascii-to-integer") riceve come parametro una stringa, e restituisce un intero rappresentante il valore espresso dalla stringa, assumendo che essa contenga un numero in notazione decimale. Per esempio, atoi("123") restituisce l'intero 123. Si scriva una propria funzione C atoi2() che faccia lo stesso. Si scriva poi un main() che, come per gli esercizi precedenti, passi ad atoi2() le stringhe passate sulla riga di comando, e stampi argomento e risultati per ciascuna.

   Avanzato **: si implementi atoi2() in modo tale che essa riproduca esattamente il comportamento di atoi() anche nei casi di errore. Si esegua il comando man atoi per i dettagli su atoi().

Salvo ove diversamente indicato, gli esercizi seguenti possono essere risolti lavorando su Eclipse. Si suggerisce di creare un progetto distinto per ogni esercizio.

1. strlen(). Se non lo si è già fatto, si svolga l'esercizio su strlen() presentato alla precedente esercitazione. Altrimenti, si passi subito all'esercizio successivo. Il testo dell'esercizio in questione è il seguente:

   La funzione di libreria strlen() prende come parametro una stringa, e restituisce la sua lunghezza. Per esempio, strlen("Ciao mamma!") restituisce 11.

   Si scriva una propria implementazione di questa funzione, chiamandola strlen2(). Si scriva poi una funzione main() che, per ciascuna delle stringhe passate sulla riga di comando, stampi la stringa, la sua lunghezza calcolata da strlen() e quella calcolata da strlen2(). Si verifichi che le due funzioni restituiscano lo stesso risultato.

2. Equivalenza array-puntatori. Se nello svolgere l'esercizio precedente è stata usata la notazione degli array (a[i] ecc.), si riscriva la strlen2() usando la notazione dei puntatori (*p ecc.); viceversa, se è stata usata la notazione dei puntatori, si riscriva strlen2() usando la notazione degli array.

3. Allocazione dinamica e strdup(). In C l'allocazione dinamica di memoria avviene tramite la funzione malloc() (definita nel file header stdlib.h. Tale funzione prende in ingresso la dimensione (in byte) del blocco di memoria che si vuole allocare, e restituisce un puntatore al blocco allocato. Per esempio, int *a=(int *)malloc(10*sizeof(int)); restituisce un puntatore a uno spazio di memoria sufficiente a contenere 10 interi. Questa operazione è analoga a dichiarare un array di 10 interi con int a[10]; (ci sono alcune differenze che verranno discusse a lezione).

   Si scriva una funzione strdup2() che, ricevuta come argomento una stringa, restituisca una copia di tale stringa, memorizzata in un'area di memoria di dimensione adeguata allocata dinamicamente. Suggerimento: si ricordi che le stringhe sono gestite come puntatori a caratteri, e che una stringa deve sempre essere terminata da un byte a 0.

4. strcmp() Scrivere una funzione C con prototipo int strcmp2(char *s, char *t) che restituisca un valore minore di 0 se s<t; 0 se s=t; un valore maggiore di 0 se s>t. In ogni caso, i confronti devono essere fatti seguendo l'ordinamento ASCII dei caratteri; una stringa più corta deve risultare minore di una più lunga che la abbia come prefisso (es: "mamma"<"mammaliturchi").

5. Uso delle strutture. Si definisca una struttura presenza che contenga le informazioni presenti in una riga del foglio presenze usato nel corso. Se non avete sott'occhio il foglio, tali informazioni sono:
   • un numero progressivo
   • cognome
   • nome
   • account
   • matricola
   • corso
   • gruppo di esercitazione
   • note
   • firma
   • percentuale di presenze
   Si curi di usare il tipo di dato corretto per ogni campo! Si definisca poi una struttura fogliopresenze che descriva l'intero foglio, con spazio per 200 studenti. Si noti che l'intestazione del foglio include data e ora, aula, gruppo e docente. Infine, si scriva una funzione stampaassenti() che, ricevuto come argomento un fogliopresenze, stampi con printf() la sua intestazione nonché i nomi e cognomi di tutti gli assenti.

   Nota: questo esercizio non ha un main(), quindi non può essere eseguito direttamente (perché sia significativo, occorrerebbe scrivere i dati degli studenti all'interno della struttura dati).

   Avanzato *: usando degli assegnamenti, si compilino (con dati di fantasia) alcune righe del fogliopresenze, e si scriva un main() che richiama la stampaassenti(). Si verifichi che il programma si comporta come atteso.

6. Uso delle union. Un punto sul piano cartesiano è definito con due coordinate (di tipo double), x e y. Si definiscano strutture dati per triangoli, quadrati, pentagoni e cerchi. Si definisca poi una struttura dati figura che possa contenere una qualunque delle figure geometriche sopra indicate (e che si sappia, in ogni istante, quale figura è contenuta nella struttura dati), senza sprecare spazio. Quanto sarà grande questa struttura dati? Si provi a stimare il risultato prima di verificarlo usando l'operatore sizeof().

   Si scriva poi una funzione perimetro() che, ricevuta come parametro una figura, restituisca il suo perimetro (come double). Nota: potreste voler usare la funzione di libreria sqrt(), che restituisce la radice quadrata di un numero. Tale funzione è definita nel file header di sistema math.h. Inoltre, dovete istruire il linker a unire al vostro codice la libreria matematica di sistema: per far ciò, potete usare l'opzione -lm del gcc oppure indicare, fra le proprietà del progetto Eclipse, che volete usare la libreria di nome m (Proprietà del progetto, pagina C/C++ build, scheda "Librerie", inserite m nella lista di librerie "opzione -l").

   Infine, si scriva una funzione main() che dichiari e inizializzi una variabile per ciascun tipo di figura, e stampi il relativo perimetro usando la funzione definita in precedenza.

7. Equivalenza dei riferimenti. Si aggiungano ai due esercizi precedenti delle operazioni di stampa che mostrino gli indirizzi e i valori corrispondenti a varie espressioni, come le seguenti:
   • struttura.campo
   • arraydistrutture[indice].campo
   • unione.campo
   • puntatoreastruttura->campo
   • (puntatoreadarraydistrutture+indice)->campo
   • (*(puntatoreadarraydistrutture+indice)).campo
   ecc. Suggerimento: si usi la specifica di formato %p di printf() per stampare il valore di un puntatore.

Salvo ove diversamente indicato, gli esercizi seguenti possono essere risolti lavorando su Eclipse. Si suggerisce di creare un progetto distinto per ogni esercizio.