FPdiario0910 < Programmazione1

Tags: view all tags
<H1>Fondamenti di Programmazione a.a. 2009-2010 <SMALL>(canale E-O)</SMALL></H1>
<BIG>
Docente: Riccardo Silvestri <BR>
Esercitatori: Toni Mancini e Paul Wollan<BR>
</BIG>


<H2>Diario delle lezioni e delle esercitazioni</H2>

<DIV style="margin-left:5%; margin-right:10%">

<DIV ALIGN="justify">
<B>Luned&igrave; 28 settembre 2009</B>
<BLOCKQUOTE>
Informazioni sul corso. Cenni sull'architettura
di un calcolatore: CPU, memoria primaria e secondaria, input/output. Struttura logica
della memoria. Linguaggio macchina, linguaggio assembly. Linguaggi ad alto livello
e compilatori. Cenni storici sul linguaggio C. Primo programma in C: stampa di una
stringa di testo. Programma che stampa la somma di due numeri: 
specifica di conversione della <CODE>printf</CODE> per gli interi.
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Mercoled&igrave; 30 settembre 2009</B>&nbsp;&nbsp;&nbsp;&nbsp;
[[FPlab300909][Laboratorio]].
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Venerd&igrave; 2 ottobre 2009</B>
<BLOCKQUOTE>
Memoria, locazioni di memoria, indirizzi e variabili. Dichiarazioni di variabili di tipo <CODE>int</CODE>. Lettura dallo
<EM>standard input</EM> tramite la funzione <CODE>scanf()</CODE>. L'operatore di indirizzo <CODE>&amp;</CODE>. 
Assegnamenti. Operatori
aritmetici: <CODE>+</CODE>, <CODE>-</CODE>, <CODE>*</CODE>, <CODE>/</CODE>, <CODE>%</CODE>. 
Esempi: 
<UL>
<LI>Programmi che leggono un intero <CODE>n</CODE> e stampano il quadrato e la sedicesima potenza di <CODE>n</CODE></LI>
<LI>Programma che legge due interi <CODE>n</CODE> e <CODE>m</CODE> e stampa il quoziente e il resto della divisione di <CODE>n</CODE>
per <CODE>m</CODE></LI>
<LI>Programma che legge un intero <CODE>s</CODE> che rappresenta un numero di secondi e stampa l'equivalente in giorni,
ore, minuti e secondi (ad es. se <CODE>s = 100000</CODE> allora l'output &egrave; 
<CODE>1 giorni 3 ore 46 minuti e 40 secondi</CODE>).</LI>
</UL>
Instruzioni di selezione: <CODE>if () - else</CODE>. Operatori relazionali: <CODE>&lt;</CODE>, <CODE>&gt;</CODE>, <CODE>&lt;=</CODE>, 
<CODE>&gt;=</CODE>, <CODE>==</CODE>, <CODE>!=</CODE>. Esempi: Programmi che leggono due o tre numeri e ne stampano il massimo.
<BR>
<B>Esercizio 1</B> &nbsp;&nbsp; Scrivere un programma che prende in input tre numeri e 
li stampa in ordine crescente. <BR>
<B>Esercizio 2</B> &nbsp;&nbsp; Scrivere un programma legge due date nel formato <CODE>g/m/a</CODE> (ad es. <CODE>17/4/2009</CODE>)
e le confronta stampando se la prima data &egrave; anteriore, posteriore o uguale alla seconda. Ad esempio, se le date sono <CODE>12/5/2009</CODE>
e <CODE>10/7/2009</CODE>, il programma deve stampare <CODE>la prima data &egrave; anteriore alla seconda</CODE>.
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Luned&igrave; 5 ottobre 2009</B>
<BLOCKQUOTE>
Discussione degli esercizi 1 e 2. Operatori logici <CODE>||</CODE> (OR) <CODE>&amp;&amp;</CODE> (AND).
Istruzioni iterative: <CODE>for ( ; ; )</CODE>. Esempi: 
<UL>
<LI>Programma che stampa 50 volte una stringa (<CODE>"Repetita iuvant"</CODE>).</LI>
<LI>Programma che prende in input un intero <CODE>n</CODE> e stampa le prime <CODE>n</CODE>
potenze di 2.</LI>
<LI>Programma che stampa il massimo di <CODE>n</CODE> numeri.</LI>
<LI>Programma che legge <CODE>n</CODE> e stampa un quadrato di <CODE>n</CODE>
righe e <CODE>n</CODE> colonne riempito con il carattere <CODE>'*'</CODE>.</LI>
</UL>
Operatori di postincremento <CODE>++</CODE>, postdecremento <CODE>--</CODE> e gli operatori
<CODE>+=</CODE>, <CODE>-=</CODE>, <CODE>*=</CODE>, <CODE>/=</CODE>,
<CODE>%=</CODE>.
<BR>
Tipi primitivi. Tipi per valori interi: <CODE>short</CODE>, <CODE>int</CODE>, <CODE>long</CODE>, <CODE>long long</CODE> e
versioni <CODE>unsigned</CODE>. Tipi per valori in virgola mobile: <CODE>float</CODE>, <CODE>double</CODE>, 
<CODE>long double</CODE>. Il tipo carattere <CODE>char</CODE>: codici ASCII. Le corrispondenti specifiche di conversione
per le funzioni <CODE>printf()</CODE> e <CODE>scanf()</CODE>: <CODE>%hd</CODE>, <CODE>%d</CODE>, <CODE>%ld</CODE>, 
<CODE>%lld</CODE>, <CODE>%hu</CODE>, <CODE>%u</CODE>, <CODE>%lu</CODE>, <CODE>%llu</CODE>, <CODE>%f</CODE>,
<CODE>%c</CODE>. 
<BR>
<B>Esercizio 3</B> &nbsp;&nbsp; Scrivere un programma che prende in input <CODE>n</CODE> numeri in virgola mobile (<CODE>float</CODE>)
e stampa la media di tali numeri.
<BR>
<B>Esercizio 4</B> &nbsp;&nbsp; Scrivere un programma che legge un intero <CODE>n</CODE> e un carattere <CODE>c</CODE> e stampa
un triangolo di altezza <CODE>n</CODE> fatto con caratteri <CODE>c</CODE>. Ad esempio, se <CODE>n = 5</CODE> e <CODE>c = 'a'</CODE>
allora il programma stampa:
<PRE>
a
aa
aaa
aaaa
aaaaa
</PRE>
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Mercoled&igrave; 7 ottobre 2009</B>&nbsp;&nbsp;&nbsp;&nbsp;
[[FPlab071009][Laboratorio]].
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Venerd&igrave; 9 ottobre 2009</B>
<BLOCKQUOTE>
Discussione degli esercizi 3 e 4. Comportamento dell'operatore di divisione <CODE>/</CODE> in funzione
del tipo degli operandi. Istruzioni iterative: <CODE>while ()</CODE>. Equivalenza con il <CODE>for ( ; ; )</CODE>. 
Esempi: 
<UL>
<LI>Programma che determina se un numero intero &egrave; un numero primo (diverse versioni).</LI>
<LI>Programma che prende in input un intero <CODE>n</CODE> e stampa il numero di cifre di <CODE>n</CODE>.</LI>
</UL>
Istruzioni iterative: <CODE>do - while ()</CODE>. Equivalenza con il <CODE>while ()</CODE>. 
Esempi:
<UL>
<LI>Programma che legge una linea di testo (una sequenza di caratteri terminata dal carattere <CODE>'\n'</CODE>)
e conta il numero di vocali e di consonanti.</LI>
<LI>Programma che legge una linea di testo e conta il numero di parole. Per parola si intende una sequenza
di caratteri alfabetici di lunghezza massimale.</LI>
</UL>
<B>Esercizio 5</B> &nbsp;&nbsp; Scrivere un programma che prende in input un intero <CODE>n</CODE> 
e stampa la somma delle cifre di <CODE>n</CODE>. Ad esempio, se <CODE>n = 1205</CODE> allora il programma
stampa <CODE>8</CODE>.
<BR>
<B>Esercizio 6</B> &nbsp;&nbsp; Scrivere un programma che legge una linea di testo e stampa la lunghezza della 
pi&ugrave; lunga parola contenuta nella linea di testo. Ad esempio, se la linea di testo &egrave; <CODE>"Qual'e' la
parola piu' lunga?</CODE> allora il programma stampa <CODE>6</CODE> se invece la linea di testo &egrave;
<CODE>"Una parola lunghissima"</CODE>, stampa <CODE>11</CODE>.
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Luned&igrave; 12 ottobre 2009</B>
<BLOCKQUOTE>
Discussione degli esercizi 5 e 6. Dichiarazione e inizializzazione di <EM>vettori</EM> (arrays) (di dimensione costante). 
Rappresentazione in memoria dei vettori.
Esempi: 
<UL>
<LI>Programma che legge una linea di testo e stampa la parola pi&ugrave; lunga contenuta nella linea.</LI>
<LI>Programma che legge una linea di testo e calcola e poi stampa le frequenze dei caratteri stampabili
contenuti nella linea di testo. Ad esempio, se la linea di testo &egrave; <CODE>"Questa frase contiene 48 (quarantotto)
caratteri"</CODE>, il programma stampa:
<PRE>
  5
( 1
) 1
4 1
8 1
Q 1
a 6
c 2
e 5
f 1
i 2
n 3
o 3
q 1
r 4
s 2
t 7
u 2
</PRE></LI>
</UL>
Alcune funzione in <CODE>ctype.h</CODE>: <CODE>isalpha()</CODE>, <CODE>isprint()</CODE>.
<BR>
<B>Esercizio 7</B> &nbsp;&nbsp; 
Scrivere un programma che legge una linea di testo e per ogni carattere che &egrave; l'iniziale di una parola
stampa il numero di parole che iniziano con quel carattere. Ad esempio, se la linea di testo &egrave; <CODE>"Una parola,
due parole, tre parole"</CODE>, il programma stampa:
<PRE>
U 1
p 3
d 1
t 1
</PRE>
<B>Esercizio 8</B> &nbsp;&nbsp; 
Scrivere un programma che legge un intero <CODE>n</CODE> (si pu&ograve; assumere che sia minore di 100) e poi
legge <CODE>n</CODE> numeri in virgola mobile (<CODE>float</CODE>) e se ci sono due numeri la cui differenza 
(in valore assoluto) &egrave; minore di <CODE>0.001</CODE> stampa <CODE>"Ci sono numeri vicini"</CODE>,
altrimenti stampa <CODE>"NON ci sono numeri vicini"</CODE>. Ad esempio, se i numeri letti sono 
<CODE>1.03, 0.056, 1.0305</CODE>, allora il programma stampa <CODE>"Ci sono numeri vicini"</CODE>.
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Mercoled&igrave; 14 ottobre 2009</B>&nbsp;&nbsp;&nbsp;&nbsp;
[[FPlab141009][Laboratorio]].
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Venerd&igrave; 16 ottobre 2009</B>
<BLOCKQUOTE>
Discussione degli esercizi 7 e 8. Discussione sullo stile e la buona struttura del codice: evitare l'uscita "brutale" da un ciclo iterativo.
Definizione di <EM>funzioni</EM>: tipo del valore ritornato, lista dei parametri. Chiamata di una funzione. Il tipo <CODE>void</CODE>.
Esempi: funzione che ritorna
la terza potenza di un numero in virgola mobile, funzione che ritorna il massimo di due interi. Passaggio dei parametri per valore e 
il caso dei vettori. Esempi: funzione che ritorna la somma dei valori di un vettore di <CODE>float</CODE>, funzione che imposta 
gli elementi di un vettore ad un valore dato. Discussione sull'importanza di una adeguata decomposizione del codice di un programma
in moduli (o funzioni). Principali vantaggi: migliora la leggibilit&agrave;; riduce la duplicazione del codice; facilita l'individuazione degli
errori; facilita le eventuali modifiche e estensioni; rende possibile la riusabilit&agrave; del codice (librerie). Cenni sulla possibilit&agrave;
di scrivere programmi su pi&ugrave; files, prototipo di una funzione. Esempio di una funzione che pu&ograve; essere utile in pi&ugrave;
programmi: funzione con prototipo <CODE>int input_linea(char chA[], int maxchars)</CODE> che legge dallo standard input una sequenza di
caratteri e li scrive nel vettore <CODE>chA</CODE> fino a che non legge <CODE>EOF</CODE>, il carattere <CODE>'\n'</CODE> o sono
stati letti <CODE>maxchars</CODE> caratteri, ritorna il numero di caratteri letti. Uso della funzione <CODE>getchar()</CODE>.
<BR>
<B>Esercizio 9</B> &nbsp;&nbsp; 
Scrivere una funzione <CODE>void ruota(char C[], int n, int k)</CODE> che ruota i caratteri
del vettore <CODE>C</CODE> di <CODE>k</CODE> posizioni a destra. Ad esempio, se
i caratteri nel vettore <CODE>C</CODE> sono <CODE>"programma"</CODE> (<CODE>n = 9</CODE>) e
<CODE>k = 3</CODE>, allora la funzione modifica il vettore in modo che contenga <CODE>"mmaprogra"</CODE>.
Scrivere anche un programma che provi la funzione.
<BR>
<B>Esercizio 10</B> &nbsp;&nbsp; 
Scrivere una funzione <CODE>int incluso(int A[], int n, int B[], int m)</CODE> che ritorna <CODE>1</CODE> se tutti i
valori nel vettore <CODE>A</CODE> (di dimensione <CODE>n</CODE>) sono anche contenuti nel vettore <CODE>B</CODE>
(di dimensione <CODE>m</CODE>), altrimenti ritorna <CODE>0</CODE>. 
Ad esempio, se <CODE>A = [2, 1, 3, 2, 1]</CODE> e <CODE>B = [5, 1, 3, 2]</CODE> allora
la funzione ritorna <CODE>1</CODE>, se invece <CODE>B = [5, 3, 2, 0]</CODE> allora la funzione ritorna <CODE>0</CODE>.
Scrivere anche un programma che provi la funzione.
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Luned&igrave; 19 ottobre 2009</B>
<BLOCKQUOTE>
Discussione degli esercizi 9 e 10. Esempio di un programma che pu&ograve; essere convenientemente decomposto
in funzioni: programma che legge dall'input due frazioni positive (nel formato <CODE>numeratore/denominatore</CODE>)
e stampa la somma delle due frazioni, sempre nello stesso formato. Ad esempio, se il programma legge le frazioni <CODE>8/15</CODE>
e <CODE>3/10</CODE>, stampa <CODE>5/6</CODE>. Funzioni per il calcolo del massimo comun divisore e per il calcolo
del minimo comune multiplo di due interi positivi. Passaggio di parametri per valore e per indirizzo. <EM>Tipi puntatore</EM>.
L'operatore di <EM>indirezione</EM> <CODE>*</CODE>. Esempio: funzione che prende in input il numeratore e il denominatore
di una frazione e la riduce ai minimi termini. Test di correttezza di una funzione tramite la generazione di input pseudo-casuali.
Le funzioni <CODE>int rand()</CODE> e <CODE>void srand(unsigned seed)</CODE> in <CODE>stdlib.h</CODE>.
<BR>
<B>Esercizio 11</B> &nbsp;&nbsp; 
Scrivere una funzione, <CODE>int parola(char chA[], int n, int k, int *plung)</CODE>, che ritorna la posizione
della <CODE>k</CODE>-esima parola contenuta nell'array <CODE>chA</CODE> (di dimensione <CODE>n</CODE>) e
restituisce in <CODE>*plung</CODE> la lunghezza di tale parola. Se il numero di parole contenute nell'array  
<CODE>chA</CODE> &egrave; minore di <CODE>k</CODE>, la funzione ritorna <CODE>-1</CODE> e 
<CODE>*plung</CODE> &egrave; lasciato invariato. Ad esempio, se <CODE>chA</CODE> contiene
la sequenza di caratteri <CODE>"La seconda parola"</CODE> (quindi <CODE>n = 17</CODE>) e <CODE>k = 2</CODE>,
allora la funzione ritorna <CODE>3</CODE> e in <CODE>*plung</CODE> restituisce il valore <CODE>7</CODE>.
<BR>
<B>Esercizio 12</B> &nbsp;&nbsp; 
Scrivere un programma (usando la funzione dell'esercizio precedente ed eventualmente altre funzioni) che legge
dall'input due linee di testo e stampa tutte le parole della prima linea che appaiono anche nella seconda. Ad esempio,
se le due linee di testo sono <CODE>"Le cose non sono solo cose"</CODE> e <CODE>"sono tante cose"</CODE>,
allora il programma stampa:
<PRE>
cose
sono
cose
</PRE>
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Mercoled&igrave; 21 ottobre 2009</B>&nbsp;&nbsp;&nbsp;&nbsp;
[[FPlab211009][Laboratorio]].
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Venerd&igrave; 23 ottobre 2009</B>
<BLOCKQUOTE>
Discussione degli esercizi 11 e 12. Le <EM>stringhe</EM>: carattere di terminazione <CODE>'\0'</CODE>, inizializzazione.
Principali funzioni della libreria standard (<CODE>string.h</CODE>) per le stringhe: <CODE>strcpy()</CODE>, <CODE>strlen()</CODE>,
<CODE>strcmp()</CODE>. Specifica di conversione <CODE>%s</CODE> per <CODE>scanf()</CODE> e <CODE>printf()</CODE>.
Esempi:
<UL>
<LI>programma che legge <CODE>n</CODE> stringhe e stampa la minima, rispetto all'ordine lessicografico
dato dalla funzione <CODE>strcmp()</CODE>.</LI>
<LI>programma che legge due stringhe e determina se sono l'una un anagramma dell'altra (ad es. <CODE>"lavagna"</CODE>
e <CODE>"valanga"</CODE>). Definizione di una
funzione <CODE>int anagramma(char *s1, char *s2)</CODE> che ritorna <CODE>true</CODE> o <CODE>false</CODE>
a seconda che le stringhe <CODE>s1</CODE> e <CODE>s2</CODE> siano l'una un anagramma dell'altra. Uso di una funzione 
<CODE>int occorrenze(char *s, char c)</CODE> che ritorna il numero di volte che il carattere <CODE>c</CODE> occorre
nella stringa <CODE>s</CODE>.</LI>
</UL>
<B>Esercizio 13</B> &nbsp;&nbsp; 
Scrivere una funzione, <CODE>char *strpar(char *s, int k, char *par)</CODE>, che copia
la <CODE>k</CODE>-esima parola contenuta nella stringa <CODE>s</CODE> in <CODE>par</CODE>,
come stringa, e ritorna il puntatore <CODE>par</CODE>. Se <CODE>s</CODE> contiene meno di <CODE>k</CODE>
parole, allora la funzione ritorna <CODE>NULL</CODE>. Sostanzialmente, <CODE>strpar()</CODE> &egrave; una versione
per stringhe della funzione <CODE>parola()</CODE> dell'esercizio 11.
<BR>
<B>Esercizio 14</B> &nbsp;&nbsp; 
Scrivere un programma (usando le funzioni <CODE>anagramma()</CODE> e <CODE>strpar()</CODE>) che prende in input
una linea di testo e poi una stringa e stampa tutte le parole contenute nella linea di testo che sono anagrammi della stringa.
Ad esempio, se la linea di testo &egrave; <CODE>"Il ratto ha mangiato la torta"</CODE> e la stringa &egrave; <CODE>"trota"</CODE>,
allora il programma stampa:
<PRE>
ratto
torta
</PRE>
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Luned&igrave; 26 ottobre 2009</B>
<BLOCKQUOTE>
Discussione degli esercizi 13 e 14. Semplici algoritmi di ordinamento: <EM>selection-sort</EM> 
e <EM>bubble-sort</EM>. Iniziata la spiegazione dell'algoritmo della ricerca binaria.
<BR>
<B>Esercizio 15</B> &nbsp;&nbsp; 
Scrivere una funzione <CODE>void ordinastr(char *str)</CODE> che ordina i caratteri
della stringa <CODE>str</CODE>. Ad esempio, se <CODE>str = "ordina char"</CODE> allora
la funzione modifica la stringa <CODE>str</CODE> cos&igrave; <CODE>" aacdhinorr"</CODE>.
<BR>
<B>Esercizio 16</B> &nbsp;&nbsp; 
Scrivere un programma che mette a confronto le funzioni <CODE>selectionsort()</CODE> e 
<CODE>bubblesort()</CODE> per ordinare vettori di interi. Misurare i rispettivi tempi di esecuzione
variando i vettori da ordinare. Ad esempio, vettori gi&agrave; ordinati, vettori con ordinamento inverso,
vettori quasi ordinati (ottenuti facendo qualche scambio in vettori ordinati) e vettori disordinati (ottenuti
generando interi pseudo-casuali con la funzione <CODE>rand()</CODE>). Il tempo di esecuzione pu&ograve;
essere misurato usando la funzione della libreria standard <CODE>clock()</CODE> in <CODE>time.h</CODE>
che ritorna il numero corrente di <EM>clocks</EM>. Un <EM>clock</EM> &egrave; una unit&agrave; di misura 
del tempo che &egrave; dipendente dalla piattaforma. La costante <CODE>CLOCKS_PER_SEC</CODE> (sempre
in <CODE>time.h</CODE>) fornisce il numero di <EM>clocks</EM> per secondo. Cos&igrave; se si vuole
misurare il numero di millisecondi dell'esecuzione di <CODE>selectionsort()</CODE> si pu&ograve;
scrivere:
<PRE>
clock_t start, end;
start = clock();        // numero di clocks subito prima della chiamata
selectionsort(V, n);
end = clock();          // numero di clocks subito dopo la chiamata
        // tempo di esecuzione in millisecondi
double tempoEsecuzione = 1000*(((double)(end - start))/CLOCKS_PER_SEC);
</PRE>
Il tipo <CODE>clock_t</CODE> &egrave; un tipo intero senza segno definito in <CODE>time.h</CODE>.
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Mercoled&igrave; 28 ottobre 2009</B>&nbsp;&nbsp;&nbsp;&nbsp;
[[FPlab281009][Laboratorio]].
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Venerd&igrave; 30 ottobre 2009</B>
<BLOCKQUOTE>
Discussione degli esercizi 15 e 16. L'algoritmo della <EM>ricerca binaria</EM>: implementazione iterativa.
Definizione <EM>ricorsiva</EM> di funzioni: fattoriale e ricerca binaria. Cenni sulla esecuzione di chiamate
(ricorsive) di funzioni e sullo <EM>stack</EM>.
<BR>
Allocazione dinamica della memoria: confronto con allocazione statica. Principali funzioni della libreria standard
(<CODE>stdlib.h</CODE>): <CODE>malloc()</CODE>, <CODE>free()</CODE> e <CODE>realloc()</CODE>.
Il tipo <CODE>void *</CODE>. L'operatore <CODE>sizeof</CODE>. Esempi: 
<UL>
<LI>funzione <CODE>char *duplicastr(char *str)</CODE> che ritorna una copia (allocata dinamicamente) 
della stringa <CODE>str</CODE>.</LI>
<LI>funzione <CODE>char *inputlinestr()</CODE> che ritorna in una stringa allocata dinamicamente la sequenza di caratteri
letti dall'input (fino a <CODE>EOF</CODE> o <CODE>'\n'</CODE>). Uso di <CODE>realloc()</CODE>.</LI>
</UL>
<B>Esercizio 17</B> &nbsp;&nbsp; 
Scrivere una funzione <CODE>long long mcd(long long a, long long b)</CODE> che ritorna il M.C.D. di <CODE>a</CODE>
e <CODE>b</CODE>. La funzione deve implementare in modo ricorsivo l'algoritmo di Euclide per il calcolo del M.C.D.
<BR>
<B>Esercizio 18</B> &nbsp;&nbsp; 
Scrivere una funzione <CODE>char *concat(char *s1, char *s2)</CODE> che ritorna una nuova stringa che contiene
la concatenazione delle stringhe <CODE>s1</CODE> e <CODE>s2</CODE>. Ad esempio, se <CODE>s1 = "Prima parte"</CODE>
e <CODE>s2 = "Seconda parte"</CODE> allora la funzione ritorna la stringa <CODE>"Prima parteSeconda parte"</CODE>.
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Luned&igrave; 2 novembre 2009</B>
<BLOCKQUOTE>
Discussione degli esercizi 17 e 18. Array multidimensionali: inizializzazione e rappresentazione in memoria. Esempi:
<UL>
<LI>funzione <CODE>void maxrighe(int nr, int nc, float M[nr][nc], float maxR[])</CODE> che ritorna nell'array
<CODE>maxR</CODE> i valori massimi delle righe della matrice <CODE>M</CODE> (che ha <CODE>nr</CODE> righe
e <CODE>nc</CODE> colonne).</LI>
<LI>funzione <CODE>void magicsquare(int n, int Q[n][n])</CODE> che riempe la matrice <CODE>nxn</CODE>
<CODE>Q</CODE> con un quadrato magico di ordine <CODE>n</CODE> (solo nel caso in cui <CODE>n</CODE>
&egrave; dispari). La semplice regola per la costruzione di quadrati magici di ordine dispari &egrave;
descritta [[http://it.wikipedia.org/wiki/Quadrato_magico][qui]].</LI>
</UL>
Array di stringhe: funzione <CODE>char **wordarray(char *text, int *pwords)</CODE> che ritorna un array di stringhe,
allocato dinamicamente, che contiene le parole contenute nella stringa <CODE>text</CODE>.
<BR>
<B>Esercizio 19</B> &nbsp;&nbsp; 
Scrivere una funzione <CODE>int ismagicsquare(int n, int Q[n][n])</CODE> che verifica se <CODE>Q</CODE>
&egrave; un quadrato magico. Se lo &egrave; ritorna la somma magica, altrimenti 
ritorna <CODE>0</CODE>. La funzione non deve solamente verificare che le somme di tutte le righe, colonne e 
diagonali coincidono ma anche che tutti gli interi da <CODE>1</CODE> a <CODE>n<SUP>2</SUP></CODE>
appaiono in <CODE>Q</CODE>.
<BR>
<B>Esercizio 20</B> &nbsp;&nbsp;
Scrivere una funzione <CODE>int *duparray(int V[], int n)</CODE> che ritorna una copia dell'array <CODE>V</CODE>.
<BR> 
<B>Esercizio 21</B> &nbsp;&nbsp; 
Scrivere una funzione <CODE>void sortstrings(char *sA[], int n)</CODE> che ordina (tramite <CODE>strcmp()</CODE>)
l'array di stringhe <CODE>sA</CODE>. 
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Mercoled&igrave; 4 novembre 2009</B>&nbsp;&nbsp;&nbsp;&nbsp;
<!--[[FPlab041109][Laboratorio]].-->  
[[http://www.dis.uniroma1.it/~tmancini/index.php?currItem=teaching.fondprog.laboratori&lab=2009-11-04&canale=E-O][Laboratorio]].
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Venerd&igrave; 6 novembre 2009</B>
<BLOCKQUOTE>
Simulazione di prova intermedia: [[%ATTACHURL%/esercizi061109sol.html][esercizi con soluzioni]].
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Mercoled&igrave; 11 novembre 2009</B>
<BLOCKQUOTE>
Prova intermedia: [[%ATTACHURL%/provaIntermedia111109sol.html][esercizi con soluzioni]].
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Luned&igrave; 16 novembre 2009</B>
<BLOCKQUOTE>
Aritmetica dei puntatori. Somma puntatore + intero: rappresentazione nella memoria. Sintassi delle parentesi quadre
ed espressione equivalente nell'aritmetica dei puntatori. Tipi array e tipi puntatori. Conversione automatica del tipo array 
nel corrispondente tipo puntatore: le eccezioni dell'operatore di indirizzo &amp; e dell'operatore <CODE>sizeof</CODE>.
Array multidimensionali e interpretazione nell'aritmetica dei puntatori delle espressioni con parentesi quadre:
puntatori ad array. I tipi <CODE><EM>T</EM> [<EM>n</EM>]</CODE> (array di <CODE><EM>n</EM></CODE> 
elementi di tipo <CODE><EM>T</EM></CODE>), 
<CODE><EM>T</EM> [<EM>n</EM>][<EM>m</EM>]</CODE> (array di <CODE><EM>n</EM></CODE> array ognuno
di <CODE><EM>m</EM></CODE> <CODE>int</CODE>) e
<CODE><EM>T</EM> (*)[<EM>n</EM>]</CODE> (puntatore ad array di <CODE><EM>n</EM></CODE> <CODE>int</CODE>).
Allocazione dinamica di matrici. Esempio,
<UL>
<LI>funzione <CODE>int **allocmatrix(int nr, int nc)</CODE> che ritorna l'indirizzo
di una matrice di interi, allocata dinamicamente, con <CODE>nr</CODE> righe e 
<CODE>nc</CODE> colonne.
</LI>
</UL>
Come si disalloca la matrice allocata tramite la funzione <CODE>allocmatrix()</CODE>.
<BR>
<B>Esercizio 22</B> &nbsp;&nbsp; 
Scrivere una funzione <CODE>int **alloctrimatrix(int n, int val)</CODE> che ritorna una matrice 
triangolare di interi, allocata dinamicamente, riempita con il valore <CODE>val</CODE>.
Ad esempio, se <CODE>n = 5</CODE> e <CODE>val = 2</CODE> la matrice allocata deve 
essere:
<PRE>
2 2 2 2 2
2 2 2 2
2 2 2
2 2
2
</PRE>
<BR>
<B>Esercizio 23</B> &nbsp;&nbsp;
Scrivere una funzione <CODE>void freetrimatrix(int n, int **M)</CODE> che disalloca la matrice 
<CODE>M</CODE>, precedentemente allocata tramite la funzione <CODE>alloctrimatrix()</CODE>.
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Mercoled&igrave; 18 novembre 2009</B>&nbsp;&nbsp;&nbsp;&nbsp;
<!--[[FPlab041109][Laboratorio]].-->  
[[http://www.dis.uniroma1.it/~tmancini/index.php?currItem=teaching.fondprog.laboratori&lab=2009-11-18&canale=E-O][Laboratorio]].
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Venerd&igrave; 20 novembre 2009</B>
<BLOCKQUOTE>
Discussione esercizi 22 e 23. Aritmetica dei puntatori: sottrazione puntatore - intero, differenza di puntatori e confronto
di puntatori. Esempio: implementazione della funzione <code>void *memmove(void *dst, void *src, int count)</code> che
copia il blocco di <code>count</code> bytes puntato da <code>src</code> nel blocco puntato da <code>dst</code> e 
ritorna <code>dst</code>. 
<br>
Tipi aggregati: <code>struct</code>. Inizializzazione di <code>struct</code>, accesso ai campi (o membri). Rinominare
tipi tramite <code>typedef</code>. Esempi, <code>struct Carta { char seme; int valore; }</code>:
<ul>
<li>funzione <code>void inizmazzo(Mazzo M)</code> che inizializza il mazzo di carte <code>M</code>,
dove <code>Mazzo</code> &egrave; il tipo dato da <code>typedef Carta Mazzo[52];</code></li>
<li>funzione <code>void stampamazzo(Mazzo M)</code> che stampa il mazzo di carte <code>M</code>.
</ul>
<B>Esercizio 24</B> &nbsp;&nbsp; 
Scrivere una funzione <code>void mescolamazzo(Mazzo M, int ns)</code> che mescola il mazzo <code>M</code>
effettuando <code>ns</code> scambi di coppie di carte (scelte in modo pseudo-casuale tramite la funzione 
<code>rand()</code>).
<BR>
<B>Esercizio 25</B> &nbsp;&nbsp;
Definire una <code>struct Studente</code> con campi: matricola, nome, cognome, num_esami. Scrivere
una funzione <code>int cerca(Studente stu[], int n, char *cog)</code> che ritorna l'indice dello studente
con cognome dato dalla stringa <code>cog</code> nell'array di <code>Studente</code> di dimensione 
<code>n</code>. Se non c'&egrave; nessun studente con quel cognome, ritorna <code>-1</code>.
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Luned&igrave; 23 novembre 2009</B>
<BLOCKQUOTE>
Discussione esercizi 24 e 25. Esempi di struct che contengono altre struct. Assegnamento di struct. L'operatore <code>sizeof</code>
applicato a struct. Puntatori a struct e la sintassi "freccia" per accedere ai campi. Le unioni (<code>union</code>): definizione e 
inizializzazione. Il <code>sizeof</code> di una union e rappresentazione in memoria. Enumerazioni (<code>enum</code>).
L'istruzione di selezione <code>switch - case</code> e l'operatore condizionale <code>( ? : )</code>. Esempio: funzione
che stampa il valore e il seme di una struct <code>Carta</code> usando enumerazioni e <code>switch - case</code>.
<br>
Iniziata la discussione di un programma che gestisce (in memoria primaria) un piccolo archivio relativo ai dipendenti
di una ipotetica azienda. Il programma dovr&agrave; permettere di effettuare almeno le seguenti operazioni: inserimento
dei dati di un nuovo dipendente, stampa dei dati relativi a tutti i dipendenti e ricerca di un dipendente in base al cognome.
Definizione della struct che rappresenta i dati relativi ad un dipendente:
<pre>
typedef struct {
    int g, m, a;
} Data;

typedef enum {
    IMP,          // impiegato
    DIR,          // dirigente
    DIRSUP        // dirigente superiore
} Ruolo;    // ogni dipendente appartiene ad uno dei ruoli sopra specificati

#define MAXL_NOM    20      // massima lunghezza del nome
#define MAXL_COG    40      // massima lunghezza del cognome
#define MAXL_SEZ    20      // massima lunghezza del nome di una sezione
#define MAXL_DIP    30      // massima lunghezza del nome di un dipartimento

typedef struct {
    char      nome[MAXL_NOM + 1];         // stringa
    char      cognome[MAXL_COG + 1];      // stringa
    Data      nascita;
    Ruolo     ruolo;
    union {
        int     livello;       // solo per impiegati
        char    sezione[MAXL_SEZ + 1]; // solo per dirigenti (nome della sezione diretta)
        char    dipart[MAXL_DIP + 1];  // solo per dirigenti superiori (nome del dipartimento diretto)
    }         info;
} Dipendente;
</pre>
<B>Esercizio 26</B> &nbsp;&nbsp; 
Scrivere una funzione <code>Dipendente inputDipendente()</code> che legge dallo standard input i valori dei 
campi di una struct <code>Dipendente</code> e la ritorna.
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Mercoled&igrave; 25 novembre 2009</B>&nbsp;&nbsp;&nbsp;&nbsp;  
[[http://www.dis.uniroma1.it/~tmancini/index.php?currItem=teaching.fondprog.laboratori&lab=2009-11-25&canale=E-O][Laboratorio]].

</DIV>
<BR>
<DIV ALIGN="justify">
<B>Venerd&igrave; 27 novembre 2009</B>
<BLOCKQUOTE>
Struttura del programma per gestire l'archivio dei dipendenti. Decomposizione del programma in due moduli:
<ul>
<li>modulo che gestisce la memorizzazione dell'archivio (funzioni: <code>void open_archivio(), void add_dipendente(Dipendente d),
int num_dipendenti(), Dipendente get_dipendente(int i), void close_archivio()</code>)
</li>
<li>modulo che gestisce l'interazione con l'utente (funzioni: <code>int main(), void inizio(), void aggiungi(), void stampa(),
void ricerca(), void fine()</code>)
</li>
</ul>
Vi &egrave; anche un modulo che contiene alcune funzioni di utilit&agrave; (<code>int input_line(char line[], int maxlen), 
int input_int(), char input_char()</code>).
Discussione dei vantaggi offerti da una tale decomposizione in moduli.
Cenni sulla separazione interfaccia-implementazione. Uso delle direttive <code>#ifndef - #endif</code> per 
evitare che il contenuto di un file header (file <code>.h</code>) possa essere incluso pi&ugrave; di una volta
nello stesso file.
Implementazione del modulo di memorizzazione (tramite un array, allocato dinamicamente). Implementazione 
dell'operazione che aggiunge un nuovo dipendente all'archivio (funzione <code>aggiungi()</code>)
e di una funzione che stampa i dati di un singolo dipendente (<code>void stampadip(Dipendente d)</code>). 
Uso di puntatori ai campi di una struct.
<br>
<B>Esercizio 27</B> &nbsp;&nbsp; 
Implementare la funzione <code>void stampa()</code>, usando la funzione <code>stampadip()</code> e le
funzioni del modulo di memorizzazione. La funzione deve stampare i dati di tutti dipendenti presenti
nell'archivio.
<BR>
<B>Esercizio 28</B> &nbsp;&nbsp;
Implementare la funzione <code>void ricerca()</code>, usando la funzione <code>stampadip()</code> e le
funzioni del modulo di memorizzazione. La funzione deve leggere un cognome dallo standard input e 
cercare nell'archivio un dipendente con quel cognome. Se &egrave; presente stampa tutti i dati di quel dipendente,
altrimenti stampa <code>"Non trovato"</code>.
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Luned&igrave; 30 novembre 2009</B>
<BLOCKQUOTE>
Discussione degli esercizi 27 e 28. Le <EM>liste</EM>: rappresentazione in memoria, vantaggi e svantaggi rispetto agli array.
Operazioni fondamentali sulle liste relativamente a liste di interi:
<pre>
typedef struct Elem {
    int          val;
    struct Elem *next;
} Elem, *List;
</pre>
Implementazione delle funzioni:
<ul>
<li><code>List add_head(List L, int val)</code> aggiunge un nuovo elemento con valore <code>val</code>
in testa alla lista <code>L</code> (<code>L</code> &egrave; il puntatore al primo elemento della lista) e
ritorna il puntatore alla lista cos&igrave; modificata.
</li>
<li><code>List add_tail(List L, int val)</code> aggiunge un nuovo elemento con valore <code>val</code>
in coda alla lista <code>L</code> e ritorna il puntatore alla lista cos&igrave; modificata.
</li>
<li><code>Elem *find(List L, int val)</code> cerca nella lista <code>L</code> il primo elemento 
con valore <code>val</code>, se lo trova ritorna il puntatore all'elemento, altrimenti ritorna 
<code>NULL</code>.
</li>
<li><code>List delete(List L, int val)</code> elimina dalla lista <code>L</code>, se presente, il primo
elemento con valore <code>val</code> e ritorna il puntatore alla lista cos&igrave; modificata.
</li>
</ul>
Implementazione del modulo di memorizzazione del programma che gestisce l'archivio dei 
dipendenti tramite una lista.
<br>
<B>Esercizio 29</B> &nbsp;&nbsp; 
Scrivere una funzione <code>List insord(List L, int val)</code> che inserisce un nuovo elemento con valore
<code>val</code> nella lista ordinata (in senso crescente) <code>L</code>, mantenendo l'ordinamento.
Ritorna il puntatore alla lista dopo l'inserimento. Ad es., se <code>L</code> &egrave; la lista 
<code>1 -> 3 -> 6 -> 8</code> e <code>val = 5</code> allora la funzione modifica la lista 
cos&igrave; <code>1 -> 3 -> 5 -> 6 -> 8</code>.
<BR>
<B>Esercizio 30</B> &nbsp;&nbsp;
Scrivere una funzione <code>List inverti(List L)</code> che inverte la lista <code>L</code> e ritorna il
puntatore alla lista invertita. Ad es., se <code>L</code> &egrave; la lista 
<code>1 -> 2 -> 3 -> 4</code> allora la funzione la trasforma cos&igrave; <code>4 -> 3 -> 2 -> 1</code>.
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Mercoled&igrave; 2 dicembre 2009</B>&nbsp;&nbsp;&nbsp;&nbsp;
[[http://www.dis.uniroma1.it/~tmancini/index.php?currItem=teaching.fondprog.laboratori&lab=2009-12-02&canale=E-O][Laboratorio]].</DIV>
<BR>
<DIV ALIGN="justify">
<B>Venerd&igrave; 4 dicembre 2009</B>
<BLOCKQUOTE>
Discussione degli esercizi 29 e 30: versione iterativa e ricorsiva della funzione <code>List inverti(List L)</code>.
Algoritmo <em>insertion-sort</em> per ordinare una lista di interi. Funzione che disalloca una lista.
<br>
Esempio di uso di liste: programma che conta le parole distinte lette dallo standard input. Possibilit&agrave; di
usare la redirezione (operatore di redirezione <code>&lt;</code> da terminale) per ridirigere lo standard input
da file. Il programma usa una lista per mantenere le parole distinte finora
trovate durante la lettura dell'input. Per migliorare l'efficienza le parole lette dall'input sono
preliminarmente mantenute in un buffer (un array di stringhe) non troppo
grande. Quando il buffer diventa pieno, le parole in esso contenute sono
riversate nella lista. Per rendere efficiente quest'ultima operazione (che
comporta, per ogni parola del buffer, il controllo che non sia gi&agrave; presente
nella lista), la lista e il buffer sono mantenuti ordinati. In questo modo,
l'operazione di riversamento &egrave; eseguita tramite una fusione delle stringhe
del buffer con quelle della lista. Decomposizione del programma in funzioni:
<pre>
#define WORDMAXLEN      100    <span style = "color:gray">// Massima lunghezza ammessa per le parole</span>
#define BUFFERSIZE      150    <span style = "color:gray">// Dimensione del buffer delle parole</span>

typedef struct WordElem {
    char *           word;   <span style = "color:gray">// Una stringa (parola)</span>
    struct WordElem *next;
} WordElem, *WordList;

<span style = "color:gray">/* Legge una parola dallo standard input, la scrive nell'array word e ne ritorna
 * la lunghezza. Se la parola e' piu' lunga di maxlen, solamente i primi
 * maxlen caratteri sono scritti nell'array word, gli altri caratteri sono letti
 * ed ignorati. I caratteri scritti in word sono sempre terminati dal carattere
 * '\0', percio' l'array word deve avere dimensione almeno maxlen + 1. */</span>
int input_word(char word[], int maxlen);
<span style = "color:gray">/* Inserisce nel array di stringhe wordBuf, ordinato e contenente n stringhe
 * (distinte), la stringa w, se non e' gia' presente. L'inserimento mantiene
 * l'ordinamemnto. Ritorna il numero di stringhe dopo l'inserimento. */</span>
int insert(char *wordBuf[], int n, char *w);
<span style = "color:gray">/* Fonde le stringhe dell'array wordBuf, contenente n stringhe (parole) ordinate
 * e distinte, nella lista ordinata di stringhe (parole) L e ritorna il puntatore
 * alla lista dopo la fusione. La fusione mantiene la lista ordinata. */</span>
WordList merge(WordList L, char *wordBuf[], int n);
<span style = "color:gray">/* Conta il numero di parole contenute nella list L */</span>
int count(WordList L);
</pre>
Implementazione del main del programma usando le funzioni sopra descritte.
<br>
<B>Esercizio 31</B> &nbsp;&nbsp; 
Scrivere una funzione <code>int uguali(!WordList L1, !WordList L2)</code> che
ritorna <code>1</code> o <code>0</code> a seconda che le due liste <code>L1</code>
e <code>L2</code> siano uguali o meno. Uguali significa che le due liste hanno la stessa 
lunghezza e elementi in posizioni corrispondenti contengono stringhe uguali.
<BR>
<B>Esercizio 32</B> &nbsp;&nbsp;
Scrivere una funzione <code>WordList !mergeList(!WordList L1, !WordList L2)</code> che ritorna 
la fusione delle due liste ordinate <code>L1</code> e <code>L2</code>. La funzione non deve n&eacute;
creare nuovi elementi n&eacute; cancellare elementi esistenti. Ad esempio, se <code>L1 = "a" -> "c" -> "hh"</code>
e <code>L2 = "bb" -> "c" -> "m" -> "z"</code> allora la lista ritornata &egrave;
<code>"a" -> "bb" -> "c" -> "c" -> "hh" -> "m" -> "z"</code>.
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Luned&igrave; 7 dicembre 2009</B>
<BLOCKQUOTE>
Discussione degli esercizi 31 e 32. Completata l'implementazione del programma
che conta le parole distinte lette dallo standard input: implementazione delle 
funzioni <code>int input_word(char word[], int maxlen)</code>, 
<code>int insert(char *wordBuf[], int n, char *w)</code>,
<code>WordList merge(!WordList L, char *wordBuf[], int n)</code> e
<code>int count(!WordList L)</code>. Dai siti <a href="http://www.liberliber.it/biblioteca/index.htm">Progetto Manuzio</a> e
<a href="http://www.gutenberg.org/catalog/">Project Gutenberg</a> si possono scaricare
tantissimi libri, italiani e stranieri, in file di testo che possono essere dati in input al programma.
<br>
Il main con argomenti: <code>int main(int argc, char *argv[])</code>. Esempio: programma che
prende come parametri una sequenza di numeri interi e ne stampa la somma. La funzione <code>sscanf()</code>.
<br>
Puntatori a funzioni: definizione e spiegazione iniziale.
<br>
<B>Esercizio 33</B> &nbsp;&nbsp; 
Modificare il programma che conta le parole distinte in modo tale che prenda
come parametro (tramite il main) un intero <code>k</code> e stampi le 
<code>k</code> parole (distinte) pi&ugrave; frequenti del testo letto dallo standard
input.
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Mercoled&igrave; 9 dicembre 2009</B>&nbsp;&nbsp;&nbsp;&nbsp;
[[http://www.dis.uniroma1.it/~tmancini/index.php?currItem=teaching.fondprog.laboratori&lab=2009-12-09&canale=E-O][Laboratorio]].

</DIV>
<BR>
<DIV ALIGN="justify">
<B>Venerd&igrave; 11 dicembre 2009</B>
<BLOCKQUOTE>
Discussione esercizio 33. <em>Puntatori a funzioni</em>: definizione e uso (operatore <code>&</code>). 
Esempi:
<ul>
<li>
La funzione <code>qsort()</code> (in <code>stdlib.h</code>) e suo uso per ordinare array 
di <code>int</code> e array di stringhe.
</li>
<li>
Funzione <code>void apply(List L, void (*op)(Elem *))</code> che applica la
funzione <code>op()</code> ad ogni elemento della lista di interi <code>L</code>.
</li>
<li>
Uso dei puntatori a funzioni per la gestione di un menu testuale:
<pre>
typedef void (*OpFunc)();

void menu(char *m[], OpFunc op[], int n)
</pre>
</li>
</ul>
<B>Esercizio 34</B> &nbsp;&nbsp; 
Considerando il tipo:
<pre>
typedef struct {
    char cognome[40];    //stringa
    char nome[20];
} Persona;
</pre>
scrivere una funzione <code>void sort_pers(Persona P[], int n)</code> che ordina 
l'array <code>P</code> (di <code>n</code> elementi) tramite la funzione 
<code>qsort()</code>.
<br>
<B>Esercizio 35</B> &nbsp;&nbsp; 
Scrivere una funzione <code>List filtro(List L, int (*f)(Elem *))</code> che elimina
dalla lista di interi <code>L</code> gli elementi <code>p</code> tali che
<code>f(p) &ne; 0</code> e ritorna il puntatore alla lista modificata.
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Luned&igrave; 14 dicembre 2009</B>
<BLOCKQUOTE>
Discussione esercizi 34 e 35. <em>File</em> ad accesso sequenziale (file di testo) e file ad accesso casuale (file binari).
Rappresentazione, da un punto di vista logico, di un file: il cursore e l'effetto delle operazioni di lettura/scrittura su di esso.
Il riferimento ad un file aperto: la struct <code>FILE</code>. Le principali funzioni, della 
libreria standard (<code>stdio.h</code>), 
per la manipolazione dei files: <code>fopen()</code> (modalit&agrave; di apertura), 
<code>fclose()</code>, 
<code>rewind()</code>, <code>fgetc()</code>,
<code>fputc()</code>, <code>fscanf()</code>, <code>fprintf()</code>, <code>fgets()</code>. 
I riferimenti allo
standard input (<code>stdin</code>) e allo standard output (<code>stdout</code>). 
Esempio: programma che prende
come argomento del main il nome di un file (di testo) e permette all'utente di stampare a video 
le linee del file
pagina per pagina (uso di <code>fopen()</code>, <code>fgets()</code> e <code>fclose()</code>).
<br>
<B>Esercizio 36</B> &nbsp;&nbsp; 
Scrivere un porogramma che prende come argomenti i nomi di due file (di testo), legge tutte le parole
contenute nel primo file memorizzandole in un array di stringhe, ordina l'array tramite 
<code>qsort()</code> e scrive nel secondo file le parole distinte (senza ripetizioni) e ordinate, 
una per linea. Si metta un limite di 100 caratteri sulla lunghezza delle parole.
<br>
<i>Suggerimenti: il primo file va aperto in lettura (<code>"r"</code>), il secondo in 
scrittura (<code>"w"</code>), per leggere le parole modificare la funzione
<code>input_word()</code> del programma che conta le parole distinte.
</i>
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Mercoled&igrave; 16 dicembre 2009</B>&nbsp;&nbsp;&nbsp;&nbsp;
[[http://www.dis.uniroma1.it/~tmancini/index.php?currItem=teaching.fondprog.laboratori&lab=2009-12-16&canale=E-O][Laboratorio]].
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Venerd&igrave; 18 dicembre 2009</B>
<BLOCKQUOTE>
Discussione esercizio 36. Implementazione del modulo di memorizzazione del programma che
gestisce un archivio di dipendenti tramite file di testo. Funzioni per il posizionamento del cursore
dei files aperti: <code>ftell()</code>, <code>fseek()</code> e le costanti <code>SEEK_SET</code>,
<code>SEEK_CUR</code> e <code>SEEK_END</code>. Differenze tra file binari e file di testo.
Cenni sull'uso delle funzioni <code>ftell()</code> e <code>fseek()</code> in un programma che 
cerca una stringa in un file di testo.
<br>
<B>Esercizio 37</B> &nbsp;&nbsp; 
Scrivere un funzione <code>int filenumocc(FILE * f, char *s)</code> che ritorna il numero di occorrenze
della stringa <code>s</code> nel file di testo <code>f</code>.
<br>
<B>Esercizio 38</B> &nbsp;&nbsp; 
Scrivere un programma che prende come argomenti (del main) i nomi di due file di testo e appende il contenuto
del secondo file al primo file. Ad esempio, se il primo file contiene <code>Testo primo file</code>
e il secondo file contiene <code>Testo secondo file</code> allora il programma modifica il
primo file cos&igrave; <code>Testo primo fileTesto secondo file</code>.
<br>
<B>Esercizio 39</B> &nbsp;&nbsp; 
Scrivere un programma che prende come argomenti (del main) i nomi di due file di testo e scrive
nel secondo file una tabella delle frequenze dei caratteri del primo file. Ad esempio, se il primo file 
contiene "i promessi sposi" (file <code>i_promes.txt</code> sul sito <a href="http://www.liberliber.it/biblioteca/index.htm">Progetto Manuzio</a>) allora il programma scrive la seguente tabella nel secondo file:
<pre>
   0        0 |  32   217652 |  64 @      1 |  96 `      1 | 128        0 | 160        0 | 192        0 | 224     2003 |
   1        0 |  33 !   1497 |  65 A   1298 |  97 a 114953 | 129        0 | 161        0 | 193        0 | 225        1 |
   2        0 |  34 "    396 |  66 B    255 |  98 b   9793 | 130        0 | 162        0 | 194        0 | 226        0 |
   3        0 |  35 #      0 |  67 C   1119 |  99 c  47033 | 131        0 | 163        0 | 195        0 | 227        0 |
   4        0 |  36 $      0 |  68 D    730 | 100 d  37532 | 132        0 | 164        0 | 196        0 | 228        0 |
   5        0 |  37 %      0 |  69 E   1038 | 101 e 120014 | 133        0 | 165        0 | 197        0 | 229        0 |
   6        0 |  38 &      0 |  70 F    395 | 102 f  10422 | 134        0 | 166        0 | 198        0 | 230        0 |
   7        0 |  39 '   9958 |  71 G    412 | 103 g  17191 | 135        0 | 167        1 | 199        0 | 231        0 |
   8        0 |  40 (    190 |  72 H     80 | 104 h  13763 | 136        0 | 168        0 | 200       92 | 232     1365 |
   9        0 |  41 )    190 |  73 I    921 | 105 i  95745 | 137        0 | 169        0 | 201        0 | 233     1262 |
  10     2990 |  42 *     57 |  74 J      3 | 106 j     20 | 138        0 | 170        0 | 202        0 | 234        0 |
  11        0 |  43 +      0 |  75 K      1 | 107 k      1 | 139        0 | 171        0 | 203        0 | 235        0 |
  12        0 |  44 ,  26324 |  76 L   1199 | 108 l  56023 | 140        0 | 172        0 | 204        0 | 236     1435 |
  13     2990 |  45 -   4416 |  77 M   1034 | 109 m  23272 | 141        0 | 173        0 | 205        0 | 237        0 |
  14        0 |  46 .   9565 |  78 N    495 | 110 n  74385 | 142        0 | 174        0 | 206        0 | 238        0 |
  15        0 |  47 /     19 |  79 O    409 | 111 o  95944 | 143        0 | 175        0 | 207        0 | 239        0 |
  16        0 |  48 0     25 |  80 P    737 | 112 p  29741 | 144        0 | 176        0 | 208        0 | 240        0 |
  17        0 |  49 1     79 |  81 Q    373 | 113 q   7638 | 145        0 | 177        0 | 209        0 | 241        1 |
  18        0 |  50 2     48 |  82 R    916 | 114 r  66912 | 146        0 | 178        0 | 210        0 | 242     2743 |
  19        0 |  51 3     32 |  83 S    945 | 115 s  55175 | 147        0 | 179        0 | 211        0 | 243        0 |
  20        0 |  52 4     21 |  84 T    406 | 116 t  62265 | 148        0 | 180        0 | 212        0 | 244        0 |
  21        0 |  53 5     35 |  85 U    162 | 117 u  34650 | 149        0 | 181        0 | 213        0 | 245        0 |
  22        0 |  54 6     35 |  86 V    409 | 118 v  23183 | 150        0 | 182        0 | 214        0 | 246        0 |
  23        0 |  55 7     15 |  87 W      4 | 119 w     15 | 151        0 | 183        0 | 215        0 | 247        0 |
  24        0 |  56 8     18 |  88 X     62 | 120 x     16 | 152        0 | 184        0 | 216        0 | 248        0 |
  25        0 |  57 9     15 |  89 Y      0 | 121 y      8 | 153        0 | 185        0 | 217        0 | 249     1817 |
  26        0 |  58 :   2663 |  90 Z     15 | 122 z   7788 | 154        0 | 186        0 | 218        0 | 250        0 |
  27        0 |  59 ;   4017 |  91 [      0 | 123 {      0 | 155        0 | 187        0 | 219        0 | 251        0 |
  28        0 |  60 <      0 |  92 \      0 | 124 |      0 | 156        0 | 188        0 | 220        0 | 252        0 |
  29        0 |  61 =      0 |  93 ]      0 | 125 }      0 | 157        0 | 189        0 | 221        0 | 253        0 |
  30        0 |  62 >      0 |  94 ^      0 | 126 ~      0 | 158        0 | 190        0 | 222        0 | 254        0 |
  31        0 |  63 ?   1335 |  95 _      0 | 127        0 | 159        0 | 191        0 | 223        0 | 255        0 |
</pre>
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Venerd&igrave; 8 gennaio 2010</B>
<BLOCKQUOTE>
Discussione esercizi 37, 38 e 39. Funzioni per leggere e scrivere file binari: <code>fread()</code>
e <code>fwrite()</code>. Implementazione del modulo di memorizzazione del programma che gestisce
un archivio di dipendenti tramite file binari.
<br>
Descrizione generale delle strutture dati <em>pila</em> (<em>stack</em>) e <em>coda</em> (<em>queue</em>):
usi tipici, operazioni fondamentali, implementazioni.
<br>
<B>Esercizio 40</B> &nbsp;&nbsp; 
Scrivere un programma che prende come argomento il nome di un file e se non esiste 
lo crea e vi scrive il primo milione di numeri primi (in ordine crescente). Poi permette
all'utente di inserire interi <code>k</code> e per ogni <code>k</code> stampa
il <code>k</code>-esimo numero primo, leggendolo dal file. Il file &egrave; binario
e i numeri primi sono memorizzati come <code>int</code>. Ad esempio, se l'utente 
inserisce <code>k = 1</code> il programma stampa <code>2</code>, se <code>k = 1000</code>
il programma stampa <code>7919</code> e se <code>k = 1000000</code> il programma
stampa <code>15485863</code>.
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Luned&igrave; 11 gennaio 2010</B>
<BLOCKQUOTE>
Discussione esercizio 40. Esempio di uso di pile: valutazione di semplici
formule booleane. Realizzazione di una piccola libreria per pile di caratteri:
separazione interfaccia-implementazione. Implementazione tramite liste.
Implementazione di una funzione <code>int boolformula(char *formula)</code>,
che valuta la formula booleana contenuta nella stringa <code>formula</code>,
usando una pila di caratteri.
<br>
<B>Esercizio 41</B> &nbsp;&nbsp; 
Modificare la funzione <code>int boolformula(char *formula)</code> per implementare
una funzione <code>int mod10formula(char *formula)</code> che valuta semplici formule
nell'aritmetica modulo 10. Tali formule sono formate dai caratteri <code>'('</code>,
<code>')'</code>, <code>'+'</code>, <code>'*'</code>, <code>'0'</code>, <code>'1'</code>,
..., <code>'9'</code>, dove gli operatori <code>'+'</code> e <code>'*'</code> sono
la somma e la moltiplicazione modulo 10. Ad esempio, la formula 
<code>3 + (4*(2 + 6 + 9)*(1 + 9) + 6)</code> ha valore 9.
</BLOCKQUOTE>
<br>
</DIV>
<DIV ALIGN="justify">
<B>Mercoled&igrave; 13 gennaio 2010</B>&nbsp;&nbsp;&nbsp;&nbsp;
<!--[[FPlab041109][Laboratorio]].-->  
[[http://www.dis.uniroma1.it/~tmancini/index.php?currItem=teaching.fondprog.laboratori&lab=2010-01-13&canale=E-O][Laboratorio]].
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Venerd&igrave; 15 gennaio 2010</B>
<BLOCKQUOTE>
Esercizi di preparazione alla prova scritta: [[%ATTACHURL%/eserciziGen1510sol.html][esercizi con soluzioni]].
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Luned&igrave; 18 gennaio 2010</B>
<BLOCKQUOTE>
Simulazione prova scritta: [[%ATTACHURL%/eserciziGen1810sol.html][esercizi con soluzioni]].
</BLOCKQUOTE>
</DIV>
<BR>
<DIV ALIGN="justify">
<B>Mercoled&igrave; 20 gennaio 2010</B>&nbsp;&nbsp;&nbsp;&nbsp;
<!--[[FPlab041109][Laboratorio]].-->  
[[http://www.dis.uniroma1.it/~tmancini/index.php?currItem=teaching.fondprog.laboratori&lab=2010-01-20&canale=E-O][Laboratorio]].
</DIV>


</DIV>
<BR>
<BR>
<BR>
<BR>