Fondamenti di Informatica II - primo modulo

[T1] M. Cadoli, M. Lenzerini, P. Naggar, A. Schaerf, Fondamenti della progettazione dei programmi: principi, tecniche e loro applicazione in C++, CittáStudiEdizioni, UTET Libreria, 1997.

Materiale didattico: testi consigliati

[T2] Capper, Introduzione al C++, McGraw Hill, 1997.

[T3] C. Batini, L. Carlucci Aiello, M. Lenzerini, A. Miola, A. Marchetti Spaccamela, Fondamenti di Programmazione dei Calcolatori Elettronici, Franco Angeli, 4a edizione, 1992.

• Lezione 1,2,3,4 - 15/1/01
  • Prima parte
    • Argomenti trattati [T1, Cap.3 fino a pag. 55] [T2, Cap. 2 e Cap. 4]
      • Presentazione del corso
      • Struttura di un programma C++
      • Primi programmi C++: somma dei primi 10 numeri interi e somma dei primi N numeri interi
      • Istruzioni, cicli while, istruzione if, dichiarazioni, istruzioni di IO
      • Tipi int, char, float e bool
    • Cosa lo studente dovrebbe sapere dopo la lezione
      • Struttura del corso e sue relazioni con altre corsi
      • Materiale didattico che si utilizza nel corso (si veda anche il programma d'esame)
      • Differenza tra programmazione e progettazione del software
      • Scrivere semplici programmi C++
    • Esercizi proposti
    • Scrivere un programma C++ che legga un intero N, legga poi N numeri interi e ne calcoli la somma (soluzione)
    • Scrivere un programma C++ che legga un intero N, legga poi N numeri interi e ne calcoli il massimo (soluzione)
  • Seconda parte
    • Argomenti trattati [T1, Cap.3 fino a pag. 55] [T2, Cap. 2 e Cap. 4]
      • Dichiarazione e definizione di variabili (programma che illustra scope)
      • Cicli for
      • Array in C++ (programma per lettura e stampa di un vettore, programma sulle stringhe)
      • Matrici in C++ (programma per lettura e stampa di una matrice)
    • Cosa lo studente dovrebbe sapere dopo la lezione:
    • Come si dichiarano array in C++
    • Scrivere e provare semplici programmi C++ su array
    • Esercizi proposti
    • Scrivere un programma C++ per il calcolo del massimo e del valore medio di un vettore (soluzione)
    • Scrivere un programma C++ per il calcolo del massimo e del valore medio di una matrice (soluzione)

• Lezioni 5,6,7 - 19/1/01
• Prima parte
  • Argomenti trattati [T1, Cap.3 fino a pag. 62] [T2, Cap. 5]
  • Funzioni in C++ (fattoriale iterativo, fattoriale ricorsivo)
  • Passaggio di parametri per valore e per riferimento (passaggio di parametri)
  • Scope statico e accesso a variabili globali (scope statico, var globali)
  • Passaggio di array come parametri (funz per leggere e stampare vettore)
  • Cosa lo studente dovrebbe sapere dopo la lezione:
  • Come si dichiarano e definiscono funzioni e procedure in C++
  • Progettare semplici funzioni in C++
  • Esercizi proposti
  • Scrivere funzione di ordinamento di un vettore basato su Selection Sort da provare in laboratorio (soluzione)
• Seconda parte
  • Argomenti trattati [Approfondimento sulla ricorsione]
  • Domini definiti induttivamente
  • Principio di induzione
  • Funzioni ricorsive (cioe' definite sulla struttura induttiva del dominio)
  • Realizzazione in C++ di funzioni ricorsive
  • Esecuzione di funzioni ricorsive utilizzando lo stack (simulazione del calcolo del fattoriale )
  • Esempi di progettazione di funzioni ricorsive e loro realizzazione (somma&molt)
  • Cosa lo studente dovrebbe sapere dopo la lezione:
  • Progettare semplici funzioni ricorsive
  • Esercizi proposti
  • Progettare funzioni ricorsive per l'esponente, il fattoriale e il <= per i numeri naturali
    assumendo di poter usare solo Succ e Pred (soluzione)

• Lezioni 8,9,10,11 - 22/1/01
• Prima parte
  • Argomenti trattati [T1, Cap.3 fino a pag. 62] [T2, Cap. 6]
  • Record in C++ (es. uso record)
  • Puntatori in C++ (es. uso puntatori)
  • Riferimenti (o alias) e puntatori (esempi: maxrif.cpp, scambia.cpp)
  • Strutture collegate di record e puntatori (esempi su liste - lettura ricorsiva e stampa iterativa)
  • Cosa lo studente dovrebbe sapere dopo la lezione:
  • Utilizzare record e puntatori per gestire strutture di dati dinamiche
  • Esercizi proposti
  • Lettura iterativa di una lista (con o senza uso del record generatore), stampa ricorsiva di una lista, cancellazione ricorsiva ed iterativa di una lista (soluzione)
• Seconda parte (laboratorio)
  • Argomenti trattati
  • Semplici programmi in C++
  • Cosa lo studente dovrebbe sapere dopo la lezione:
  • Scrivere, compilare ed eseguire semplici programmi C++
  • Esercizi proposti
  • Tutti quelli che non si riesce a finire in laboratorio (soluzioni)
  • Scrivere funzione di ordinamento di un vettore basata su Bubble Sort (soluzione)

• Lezioni 12,13,14 - 26/1/01
• Prima parte
  • Argomenti trattati [T1, Cap.3 fino a pag. 62] [T2, Cap. 6]
  • Aritmetica dei puntatori, relazione tra array e puntatori>
  • Array dinamici (into ad array dinamici, es. uso array dinamici vs liste)
  • Matrici dinamiche(intro a matrici dinamiche)
  • Cosa lo studente dovrebbe sapere dopo la lezione:
  • Utilizzare array e matrici dinamiche
  • Esercizi proposti
  • Scrivere programma che legga due interi M ad N, legga M*N interi memorizzandoli in una matrice dinamica e stampi gli indici di riga e colonna del elemento di valore massimo della matrice(soluzione)
• Seconda parte
  • Argomenti trattati
  • Programmi su record e puntatori in C++
  • Cosa lo studente dovrebbe sapere dopo la lezione:
  • Scrivere, compilare ed eseguire semplici programmi su puntatori e record in C++
  • Esercizi proposti
  • Tutti quelli che non si riesce a finire in laboratorio (soluzioni)

• Lezioni 15,16,17,18 - 29/1/01
• Prima parte
  • Argomenti trattati [T1, Cap. 4, par. 4.1, 4.2, 4.3, 4.4, 4.11]
  • Introduzione alle classi in C++
  • Cosa lo studente dovrebbe sapere dopo la lezione:
  • Saper leggere semplici dichiarazioni di classi
  • Conoscere la distinzione tra campi dati e campi funzioni, e tra campi pubblici e campi privati
  • Conoscere la distinzione tra file .h e file .cpp nella definizione di classi
  • Esercizi proposti
  • Terminare la definizione dei costruttori della classe tempo
• Seconda parte
  • Argomenti trattati[T1, Cap. 4, par. 4.5, 4.9.1]
  • Costruttori
  • Cosa il C++ da' gratis ad una classe (costruttore a zero argomenti, costruttire di copia, assegnazione)
  • Semplici esercizi su classi in C++
  • Cosa lo studente dovrebbe sapere dopo la lezione:
  • Saper utilizzare i costruttori nella definizione di una classe
  • Sapere cosa il C++ da' per default ad una classe
  • Scrivere, compilare ed eseguire semplici programmi su classi
  • Esercizi proposti
  • Tutti quelli che non si riesce a finire in laboratorio (soluzioni)

• Lezioni 19,20,21 - 2/2/01
• Prima parte e seconda parte
  • Argomenti trattati [T1, Cap. 4, par. 4.8, 4.9, 4.21]
  • Campi static di una classe
  • Overloading di operatori, overloading di funzioni esterne ad una classe
  • Funzioni friend di una classe
  • Classi clienti di altre classi
  • Cosa lo studente dovrebbe sapere dopo la lezione:
  • Sper utilizzare campi static
  • Sapere ridefinire operatori di classe, saper ridefinire l'operatore di output
  • Saper definire funzioni friend
  • Esercizi proposti
  • Scrivere overloading di operator+ per tempo, sia come funzione membro, che come funzione esterna friend (si veda [T1, 4.9, 4.9.2]).
  • A partire da telefonata.h (si veda [T1, 4.12]) scrivere il telefonata.cpp. Inoltre analizzare in dettaglio quali costruttori di tempo e di telefonata sono invocati dall'istruzione:
    telefonata t1=telefonata(tempo(15,0),tempo(15,5),555555);
  • Studiare [T1, par. 4.6, 4.7].

• Lezioni 22,23,24 - 9/2/01
  • Prima e seconda parte
    • Argomenti trattati [T1, Cap. 4, par. 4.12 - 4.19]
    • Il problema dell'interferenza
    • Ridefinizione del costruttore di copia
    • Ridefinizione dell'assegnazione
    • Ridefinizione del distruttore
    • La classe Pila
    • Cosa lo studente dovrebbe sapere dopo la lezione:
    • Sper definire una classe cliente di un'altra
    • Saper evitare il problema dell'interferenza ridefinendo costruttore di copia e assegnazione
    • Saper ridefinire il distruttore
    • Esercizi proposti
    • Riimplementare la classe Pila utilizzando un array dinamico per la rappresentazione dei valori

• Lezioni 25,26,27,28 - 12/2/01
• Prima parte
  • Argomenti trattati [T1, Cap. 1, Cap. 2]
  • Ciclo di vita e qualita' del software
  • La fase di progettazione del sofware
  • Principi di progettazione
  • Tecniche di progettazione: la modularizzazione
  • Cosa lo studente dovrebbe sapere dopo la lezione:
  • Conoscere le fasi del ciclo di vita e le qualita' del software ed i principi della progettazione
  • Cosa e' la modularizzazione
• Seconda parte (laboratorio)
  • Realizzare la classe CollOrd che incapsula in una classe la struttura dati basata su array dinamici vista nelle Lez 12,13,14: cosasifa.txt (soluzione)

• Lezioni 29,30,31 - 16/2/01
• Prima e seconda parte
  • Argomenti trattati [T1, Cap. 9]
  • La modularizzazione nella fase di concettualizzazione
  • La modularizzazione nella fase di realizzazione
  • Esercizio su modularizazione per oggetto in C++(soluzione)
  • Esempi di semplici programmi su piu' file
  • Cosa lo studente dovrebbe sapere dopo la lezione:
  • Come si usa la tecnica della modularizzazione nella progettazione del software
  • Esercizi proposti
  • MasterMind (soluzione)

• Lezioni 32,33,34,35 - 19/2/01
• Prima parte
  • Argomenti trattati [T1, Cap. 10 - escluso 10.3]
    • La specifica di tipi astratti
  • Cosa lo studente dovrebbe sapere dopo la lezione:
  • Il linguaggio di specifica dei tipi astratti
  • Saper analizzare la specifica di tipi astratti
  • Saper specificare tipi astratti
  • Esercizi proposti
  • Analizzare la specifica di tutti i tipi astratti riportati nel Cap. 10 di [T1]
• Seconda parte
  • Argomenti trattati [T1, Cap. 12 fino a 12.5 incluso]
  • La realizzazione di tipi astratti mediante classi
  • Schemi realizzativi
  • Cosa lo studente dovrebbe sapere dopo la lezione:
  • Il metodo generale per realizzare un tipo astratto mediante una classe
  • Caratteristiche dei vari schemi realizzativi
• Terza parte
  • Argomenti trattati [T1, Cap. 4, par. 4.22]
  • Template in C++
  • Esempio: parametrizzazione della classe Pila
  • Cosa lo studente dovrebbe sapere dopo la lezione:
  • Parametrizzare una classe attraverso l'uso dei template
  • Scrivere, compilare ed eseguire programmi che fannu uso di template
  • Esercizi proposti
  • Parametrizzazione attraverso i template della classe CollOrd [Lez 25,26,27,28]

• Lezioni 36,37,38 - 23/2/01
• Prima e seconda parte
  • Argomenti trattati [T1, Cap. 12, par. 12.6]
  • Schema realizzativo funzionale con condivisione
  • Schema realizzativo funzionale senza condivisione
  • Schema realizzativo con side-effect senza condivisione
  • Progettazione della classe Insieme con diversi i schemi realizzativi
  • Cosa lo studente dovrebbe sapere dopo la lezione:
  • I principi generali con cui si progetta una classe secondo i diversi schemi realizzativi
  • Vantaggi e svantaggi dei diversi schemi realizzativi
  • Esercizi proposti
  • Realizzare la classe Insieme che facemdo uso dello schema realizzativo con side-effect e senza condivisione
  • Analizzare la realizzazione della classe Insieme che fa uso dello schema realizzativo con side-effect e condivisione

• Lezioni 39,40,41 - 2/3/01
• Prima parte
  • Argomenti trattati [T1, Cap. 10, par. 10.3]
  • Astrazioni di valori e astrazioni di entita'
  • La nozione di uguaglianza per astrazioni di velori e astrazioni d'entita'
  • Il tipo astratto, astrazione per entita', CassaCambio
  • Cosa lo studente dovrebbe sapere dopo la lezione:
  • Quali sono le caratteristiche fondamentali che distinguono tipi astratti che sono astrazione di valori semplici, e quelli che sono astrazione d' entita'.
• Seconda parte
  • Argomenti trattati [T1, Cap. 12, par. 12.8]
  • Classi astrazione di valori semplici
  • Classi astrazione di valori collezione
  • Classi astrazione di entita'
  • Cosa lo studente dovrebbe sapere dopo la lezione:
  • Come si realizzano classi astrazione di valori semplici, valori collezione, di entita'

• Lezioni 42,43,44,45 - 5/3/01
  • Prima parte
    • Argomenti trattati [T1, Cap. 12, par. 12.8]
    • Realizzazione delle relazioni has-a e has-many
    • Sharing
    • Realizzazione della classe Persona
    • Cosa lo studente dovrebbe sapere dopo la lezione:
    • Come si realizzano le relazioni has-a e has-many
    • Differenza tra sharing ed interferenza
  • Seconda parte (laboratorio)
    Argomenti trattati [T1, Cap. 12]
    • Realizzare il tipo astratto albero binario utilizzando:
      • schema funzionale con condivisione
      • schema funzionale senza condivisione
    • Cosa lo studente dovrebbe sapere dopo la lezione:
    • Realizzare tipo astratto in modo funzionale con condivisione
    • Realizzare tipo astratto in modo funzionale senza condivisione
    • Esercizi proposti
    • Tutti quelli che non si riesce a finire in laboratorio (soluzioni)

• Lezione 46,47,48 - 9/3/01
• Argomenti trattati
• Esercizio d'esame (appello 21/7/99)
• Soluzione
• Esercizi proposti
• Esercizio d'esame (appello 26/4/99)

• Lezione 49,50,51 - 16/3/01
• Argomenti trattati
• Esercizio d'esame (appello 26/4/99)
• Soluzione
• Esercizi proposti
• Esercizio d'esame (appello 21/12/98a)

• Lezione 52,53,54,55 - 19/3/01
• Argomenti trattati
• Esercizio d'esame (appello 21/12/98a)
• Soluzione
• Esercizi proposti
• Esercizio d'esame (appello 21/12/98b)
• Tutti gli esercizi d'esame dati agli appelli degli anni passati