Lezioni di gennaio

Le lezioni del mese di gennaio saranno esercitazioni e discussioni sul progetto.

Le lezioni si terranno nei soliti orari e nella stessa aula, ma solo se ci sarà una sufficiente partecipazione di studenti.

Quindi procederemo così: chi vuole partecipare a una delle prossime lezioni, mi mandi una email. In base alle richieste ricevute pubblicherò sul blog un avviso per dirvi se la lezione si terrà o no.

Il mercoledì sono sempre disponibile nell'orario di ricevimento studenti (ore 11-13).

La prossima lezione potrebbe quindi essere martedì 9 gennaio: chi vuole partecipare mi scriva.

Buon Natale e buon 2007 a tutti!

Lezione del 19 dicembre

Salve a tutti. Ieri non sono riuscito a raggiungere la città universitaria causa traffico. La lezione sarebbe dovuta essere un'esercitazione (il programma del corso era terminato il 15 dic). Quindi la faremo nelle lezioni di gennaio. Guardate le istruzioni relative alle lezioni di gennaio che sto per postare.

Ereditarietà

Lezione del 15 dicembre
[30 presenti]


Argomenti trattati:

• derivazione
• polimorfismo

Podcast della lezione:
http://multicommunity.di.uniroma1.it/podcast/panizziC++20061215.mp3


Codice C++ di esempio realizzato a lezione:
Tutti i file si trovano su: http://multicommunity.di.uniroma1.it/learning/50_course/1381/codice15dic.zip

Dispense online:
Ereditarietà

Standard Library

Lezione del 12 dicembre
[47 presenti]


Argomenti trattati:

• concetti di base della standard library
• contenitori
• iteratori
• esempi
  

Podcast della lezione:
http://multicommunity.di.uniroma1.it/podcast/panizziC++20061212.mp3


Codice C++ di esempio realizzato a lezione:
Tutti i file si trovano su: http://multicommunity.di.uniroma1.it/learning/50_course/1379/contenitore.cpp

Dispense online:
Standard Library: contenitori, iteratori, algoritmi generici

Standard Library e Template

Lezione del 5 dicembre
[33 presenti]


Argomenti trattati:

• concetti generali della standard library
• template
  

Podcast della lezione:
http://multicommunity.di.uniroma1.it/podcast/panizziC++20061205.mp3


Codice C++ di esempio realizzato a lezione:
Tutti i file si trovano su: http://multicommunity.di.uniroma1.it/learning/50_course/1380/codice5dicembre.zip

Dispense online:
Template, complessità

Gestione dell'interferenza

Lezione del 1 dicembre
[33 presenti]


Argomenti trattati:

• gestione dell'interferenza: costruttore di copia, operatore di assegnazione, distruttore
• esempio classe lista
  

Podcast della lezione:
http://multicommunity.di.uniroma1.it/podcast/panizziC++20061201.mp3


Codice C++ di esempio realizzato a lezione:
Tutti i file si trovano su: http://multicommunity.di.uniroma1.it/learning/50_course/1378/20061201.zip

Dispense online:
Gestione della memoria: costruttore di copia, operatore di assegnazione, distruttore, interferenza

Illustrazione del progetto

Lezione del 28 novembre
[.. presenti]


Argomenti trattati:

• illustrazione del progetto

Podcast della lezione:
http://multicommunity.di.uniroma1.it/podcast/panizziC++20061128.mp3

Progetto di Programmazione a oggetti

Tecnologie Informatiche
A.A. 2006/2007

Introduzione

Una grande Università che sul proprio sito web riceve molti accessi al giorno decide di replicare il contenuto del proprio server principale (di seguito: SERVER) per diminuire il carico di lavoro e la occupazione di banda su di esso. Per fare ciò vuole creare una rete di altri server, (di seguito: PROXY), con il requisito fondamentale che essi si aggiornino automaticamente ai cambiamenti del SERVER, quali l'aggiunta di nuove pagine web (FILE) e la modifica di FILE esistenti. I browser degli utenti (CLIENT) verranno quindi indirizzati sui PROXY invece che sul SERVER, visualizzeranno un sito sempre aggiornato e non sovraccaricheranno il SERVER principale.

L'Università, prima di realizzare la rete di PROXY, vuole simulare l'intero sistema con un programma scritto in linguaggio C++. Nel seguito sono descritti il meccanismo dettagliato del sistema e i requisiti per la sua simulazione.

Descrizione del sistema

Il CLIENT

Il CLIENT è un computer dotato di un browser e di una memoria cache sulla quale vengono memorizzate le pagine web (FILE) accedute più di recente.
Il CLIENT tiene traccia della data di memorizzazione di ogni FILE nella cache.
Ogni CLIENT si connette alla rete attraverso un provider. Questa informazione sarà utilizzata per assegnare al client il PROXY più vicino.
Ogni volta che un utente richiede una pagina sul suo browser (ad esempio la pagina www.università.it/index.html), il CLIENT esegue questi passi:

1. interroga il DNS, cioè un server apposito che restituisce l'indirizzo del PROXY più vicino (anziché l'indirizzo del SERVER)
   
2. verifica l'eventuale possesso del FILE (pagina) in cache. Se il FILE c'è, il CLIENT chiede al PROXY la data di ultima modifica della pagina e la confronta con la data di memorizzazione del FILE in cache. Se i due FILE hanno la stessa data allora il CLIENT non fa altre richieste, ma mostra direttamente la pagina. Altrimenti prosegue con il prossimo passo.
3. il CLIENT chiede il FILE al PROXY, lo visualizza e lo memorizza nella cache.

Chiameremo le due richieste di cui ai passi 2 e 3, rispettivamente: LastMod() e Get().

Il PROXY

Il PROXY è un computer in grado di rispondere alle richieste dei CLIENT e di eseguire, a sua volta, delle richieste al SERVER. Il PROXY ha una memoria dove mantiene i FILE.
Quando il PROXY riceve una richiesta, sia LastMod() che Get(), per poter rispondere deve prima verificare l'aggiornamento del FILE nella sua memoria. Poi potrà rispondere, rispettivamente:

1. inviando la data dell'ultimo aggiornamento del file, nel caso di richiesta LastMod()
2. inviando il file stesso, nel caso di richiesta Get()

L'aggiornamento del file si verifica in questo modo:

1. Il PROXY deve verificare il possesso del FILE nella sua memoria.
2. Se sì, deve verificare che non sia stato modificato sul SERVER, mediante una richiesta LastMod() analoga a quella del CLIENT.
   
3. Se è stato modificato o se non era presente in memoria deve richiedere il FILE al SERVER (mediante una opportuna Get()) e (re)inserirlo in memoria.
   

Il SERVER

Il SERVER mantiene tutti i FILE, può rispondere alle richieste LastMod() e Get(), e, nel caso gli venga richiesto un file non esistente, restituisce un file speciale chiamato ERRORFILE. Inoltre è possibile aggiungere nuovi FILE sul SERVER e aggiornare file esistenti.

Modellazione

Modellare il sistema come segue.

• una classe File. Ogni oggetto ha un contenuto, come stringa di testo. Ha un metodo per stamparsi e uno per restituire la propria lunghezza
• una classe base Computer, caratterizzata dalle seguenti strutture dati e dai seguenti metodi:
• un repository di FILE, con filename, size, date
• un log delle operazioni eseguite
• Add(), aggiunge un file al repository
• Touch(), aggiorna la data di un FILE alla data corrente (simula un aggiornamento del file)
• LastMod(), restituisce la data di un FILE
• Get(), restituisce il contenuto di un file
• Log(), aggiorna il log con l'operazione eseguita
• Stat(), stampa le statistiche relative al log
• una classe derivata Proxy, caratterizzata dalle seguenti strutture dati e dai seguenti metodi:
• Get() e LastMod() modificati per la verifica e l'aggiornamento del FILE
• gestione dell'ERRORFILE (non deve essere mai memorizzato in cache)
  
• una classe derivata Server, caratterizzata dalle seguenti strutture dati e dai seguenti metodi:
• Get() e LastMod() modificati per la gestione dei FILE inesistenti
• classe Dns
• classe Client, caratterizzata dalle seguenti strutture dati e dai seguenti metodi:
• stampa del FILE (simula la visualizzazione di una pagina)
• richiesta di un file

Realizzare un main() che, leggendo un file di configurazione in un formato a scelta, esegua una simulazione con 100 CLIENT, 4 PROXY, 1 SERVER, 1 DNS, 5 FILE.

Esempi di overloading; Costruttore di copia

Lezione del 24 novembre
[45 presenti]


Argomenti trattati:

• overloading degli operatori ++, <<>
• overloading dell'operatore [] per la classe Punto
• costruttore di copia
• classe Lista: problema dell'interferenza (condivisione di memoria + side effect)
  

Podcast della lezione:
http://multicommunity.di.uniroma1.it/podcast/panizziC++20061124.mp3


Codice C++ di esempio realizzato a lezione:
Tutti i file si trovano su: http://multicommunity.di.uniroma1.it/learning/50_course/1369/20061124.zip

Dispense online:
Gestione della memoria: costruttore di copia, operatore di assegnazione, distruttore, interferenza

Overloading degli operatori

Lezione del 17 novembre
[40 presenti]


Argomenti trattati:

• classe Complesso:
  
• dichiarazione,
  
• definizione
  
• esempio d'uso
• soluzione alla domanda 19 del test di esonero
• overloading degli operatori
  

Podcast della lezione:
http://multicommunity.di.uniroma1.it/podcast/panizziC++20061117.mp3


Codice C++ di esempio realizzato a lezione:

• complesso.h
• complesso.cpp
• usacomplesso.cpp
• domanda19.cpp
  

Dispense online:
Esempi, overloading degli operatori

Soluzione della prova intermedia - SECONDA PARTE

Ecco la soluzione della seconda parte della prova del 10 novembre scorso (il programma).

#include <iostream>
using namespace std;

void LeggiIn(int* v)
{ for (int i = 0; i < 10; i++)
    cin >> v[i];
}

int ContaDifferenti(int* v)
{ int ultimo = v[0];
  int quanti = 1;
  for (int i = 1; i < 10; i++)
  { if (v[i] != ultimo)
    { quanti++;
      ultimo = v[i];
    }
  }
  return quanti;
}

int AllocaECopia(int*& w,int* v)
{ int n = ContaDifferenti(v);
  w = new int[n];
  w[0] = v[0];
  int i = 1, j = 0;
  while (i < 10)
  { if (v[i] != w[j])
    { j++;
      w[j] = v[i];
    }
    i++;
  } 
  return n;
}
    
int Sostituisci(int* w, int n)
{ if (n == 0)
    return 0;
  w[0] = w[0] + Sostituisci(w+1, n-1);
  return w[0];
}
     
int Sum(int x)
{ static int accumulatore = 0;
  accumulatore = accumulatore + x;
  return accumulatore;
}
       
void Stampa(int* v, int* w, int n, int t)
{ for (int i = 0; i < 10; i++)
    cout << "v[" << i << "]=" << v[i] << endl;
  cout << endl;
  for (int i = 0; i < n; i++)
    cout << "w[" << i << "]=" << w[i] << endl;
  cout << endl;
  cout << "t=" << t << endl;
}

main()
{ // domanda a)
  int v[10];
  LeggiIn(v); 
  
  // domanda b)
  int* w;
  int n = AllocaECopia(w,v); 
  
  // domanda c)
  Sostituisci(w,n); 
  
  // domanda d)
  int t;
  for (int i = 0; i < n; i++) 
    t = Sum(w[i]); 
      
  // domanda e)
  Stampa(v,w,n,t);
  
  system("PAUSE");
}

Correzione dell'esonero

Lezione del 14 novembre
[37 presenti]

Argomenti trattati:

• Visione dei compiti d'esonero (test a risposta multipla) da parte degli studenti.
  
• Soluzione alla lavagna di tutte le domande del test d'esonero con spiegazione delle motivazioni per le risposte esatte e per quelle sbagliate.

Podcast:
http://multicommunity.di.uniroma1.it/podcast/panizziC++20061114.mp3

"Sulla rifiutabilità dell'esonero"

Chi non è contento del voto dell'esonero può fare come segue:

1. svolgere il progetto
2. sostenere l'esame. Gli verrà proposto un voto per il progetto e quindi un voto totale che comprende il bonus e la media con l'esonero
   
3. rifiutare il voto mantenendo il progetto.
   
4. Tornare all'appello successivo a sostenere solamente il test a risposta multipla. Ovviamente, il voto dell'esonero è perso e viene sostituito dal nuovo voto (non si può scegliere il migliore). Quindi verrà ricalcolato il voto totale.
   

NB: Chi rifiuta il voto all'esame può decidere di rifiutare il solo esonero, o il solo progetto, o entrambi. Il bonus non si può rifiutare (e quindi non si può rifare).

NB2: Ogni voto viene mantenuto per 2 anni (stessa validità del programma del corso). Quindi potete utilizzare il voto dell'esonero del 10 nov scorso in tutti i miei appelli fino al 9 novembre 2008.

L'orario di ricevimento studenti di mercoledì 15 novembre è così modificato:

dalle 9:30 alle 10:30

(La variazione ha effetto solo per mercoledì 15)

Il docente

Emanuele Panizzi

Risultati della prova intermedia - PRIMA PARTE

Ecco i risultati della prima parte della prova intermedia di oggi (l'esonero). Ho regalato un punto a tutti.

Qui trovate il testo del compito (il disegnino della domanda 2 non si vede. Chi è interessato può passare a prendere una copia cartacea a ricevimento studenti).

NB: ricordate che la domanda 20 aveva un refuso: la graffa chiusa sta all'ultima riga, come vi ho detto e scritto alla lavagna durante la prova.


RISPOSTE ESATTE:
1c, 2c, 3a, 4b, 5c, 6b, 7b, 8b, 9a, 10c, 11a, 12b, 13d, 14a, 15b, 16a, 17c, 18a, 19b, 20-(=stampa 5 volte 1), 21c, 22b, 23a, 24d, 25b, 26b, 27b, 28b, 29a, 30a.

Esercitazione: classe Punto

Lezione del 31 ottobre
[46 presenti]


Argomenti trattati:

• dichiarazione della classe Punto
• definizione delle funzioni proprie della classe
  

Podcast della lezione:
http://multicommunity.di.uniroma1.it/podcast/panizziC++20061031.mp3


Codice C++ di esempio realizzato a lezione:

• punto.h
• punto.cpp
  

Dispense online:
Esempi

Avviso: prove intermedie - sospensione lezioni

Nella settimana dal 6 al 10 novembre non ci sono lezioni per consentire la preparazione e lo svolgimento delle prove intermedie.
Venerdì 3 novembre non c'è lezione.

Informazioni sulla prova di esonero

La prova di esonero si terrà il 10 novembre 2006 alle ore 14 in aula 1 nef.

Sarà divisa in due parti: un test e un programma.


Prima parte: test

E' un test contenente 30 domande a scelta multipla sugli argomenti trattati nel corso fino alla data dell'esonero, da svolgere individualmente.
Tempo concesso: 40 minuti.
Non sarà possibile:

• discutere con i colleghi
• consultare libri o appunti
• usare computer
• comunicare con telefonino

Il voto del test, in trentesimi (un punto per domanda), farà media con il voto del progetto. La prova è superata se il voto è >=18, altrimenti la si dovrà sostenere nuovamente in sede di esame.


Seconda parte: programma

Consiste nella realizzazione di un programma C++. Si consiglia di portare con sé il computer laptop per editare, compilare ed eseguire (provare) il programma prima di ricopiarlo sul foglio di carta. NB: la consegna è accettata esclusivamente su carta. La prova può essere svolta in collaborazione con i colleghi; in questo caso si può consegnare un unico programma scrivendo sul foglio protocollo il nome e il numero di matricola di tutti coloro che hanno collaborato.
Tempo concesso: 40 minuti.
Sarà possibile usare il pc, consultare libri e appunti, scambiare idee con tutti i colleghi presenti.

Il voto del programma, nell'intervallo 0..30, sarà moltiplicato per 0,1 e il risultato verrà sommato alla media del test e del progetto. Questa parte è superata in tutti i casi (non c'è sbarramento al 18). Questa parte non è obbligatoria, ma non potrà essere sostenuta in sede di esame.

Il voto finale dell'esame è:
(vototest+votoprogetto)/2+votoprogramma*0,1

All'esame, se il voto finale è >30, viene automaticamente assegnata la lode.

Definizione delle funzioni proprie

Lezione del 27 ottobre
[52 presenti]


Argomenti trattati:

• layout dell'oggetto
  
• puntatore this
  
• definizione dei metodi (funzioni proprie) della classe
• accesso ai campi dell'oggetto
  
• oggetto di invocazione costante
  
• parametri costanti e ritorno per riferimento
  
• overloading
  

Podcast della lezione:
http://multicommunity.di.uniroma1.it/podcast/panizziC++20061027.mp3


Codice C++ di esempio realizzato a lezione:

• coppia.h
• coppia.cpp
  
• usocoppia.cpp
• retrif.cpp
  

Dispense online:
Classi

Classi

Lezione del 24 ottobre
[59 presenti]


Argomenti trattati:

• tipo di dato astratto
  
• classi e oggetti
• dichiarazione della classe
• campi e funzioni proprie
  
• costruttore
• information hiding: parte pubblica e parte privata
• oggetto di invocazione
  

Podcast della lezione:
http://multicommunity.di.uniroma1.it/podcast/panizziC++20061024.mp3


Codice C++ di esempio realizzato a lezione:

• coppia.h
  
• usocoppia.cpp

Dispense online:
Classi

Esercizi sulla ricorsione

Per esercitarsi sulla ricorsione utilizzando le strutture dati viste fin'ora:

1. Scrivere una funzione ricorsiva che calcoli la somma degli elementi di un array di int
2. Scrivere una funz. ric. che restituisca il massimo valore degli elementi di un array di interi.
3. Scrivere una funzione ric. che, dato il puntatore a una stringa, conti il numero di spazi in essa contenuti.
4. Scrivere una f.ric. che, dati due array di interi ordinati, stampi tutti gli elementi prendendoli ordinatamente dai due array: ad esempio, dati i due array
• 1|3|4|5|7|8|10|11
• 1|2|6|7|20|21

stampa: 1|1|2|3|4|5|6|7|7|8|10|11|20|21

Fare attenzione a progettare correttamente l'intestazione delle funzioni (tipo di ritorno e tipo dei parametri formali).

Ricorsione

Lezione del 20 ottobre
[53 presenti]


Argomenti trattati:

• principio di induzione
  
• funzioni ricorsive in C++
• principio di funzionamento
  

Podcast della lezione:
http://multicommunity.di.uniroma1.it/podcast/panizziC++20061020.mp3


Codice C++ di esempio realizzato a lezione:

• ricorsione.cpp
  
• fatt_r.cpp
• listaric.cpp
  

Dispense online:
Ricorsione

Visibilità e ciclo di vita delle variabili

Lezione del 17 ottobre
[54 presenti]


Argomenti trattati:

• visibilità delle variabili (scope)
• ciclo di vita delle variabili
  

Podcast della lezione:
http://multicommunity.di.uniroma1.it/podcast/panizziC++20061017.mp3


Codice C++ di esempio realizzato a lezione:

• visibilita.cpp
• ciclodivita.cpp
• staticvars.cpp
  

Dispense online:
Funzioni, passaggio di parametri, visibilità, ciclo di vita, stack e record di attivazione

Sui prototipi delle funzioni

Risposta alla domanda 2 dello studente Emanuele del 14 ottobre scorso.

In C++ è necessario dichiarare le funzioni prima di utilizzarle. Questo si può fare in due modi:

1. anteponendo il codice dell'intera funzione a tutte le funzioni che la usano (come abbiamo fatto negli esempi in aula)
2. b) anteponendo il solo "prototipo" cioè l'intestazione della funzione.

Ad esempio, questo programma non funzionerebbe se non togliessimo il commento alla terza riga:

#include

using namespace std;
// int f();

main()
{ int x = 2;
  cout << f(x) << endl;
  system("PAUSE");
}

int f(int i)
{ return 100*i; }

Nella compilazione di un programma che invoca una funzione è necessario conoscere solo gli elementi dell'intestazione della funzione: il nome, il tipo di ritorno, il numero e i tipi dei parametri che la funzione accetta. Questo permette al compilatore di effettuare il type checking (controllo dei tipi) e di produrre il giusto codice assembly per la chiamata e il ritorno dalla funzione. Non è invece necessario conoscere il contenuto del corpo della funzione, la cui compilazione può essere effettuata separatamente.

Normalmente le intestazioni di tutte le funzioni di un file .cpp vengono raccolte in un file .h che poi viene incluso da tutti i file che vogliono usare quelle funzioni.

Funzioni e passaggio di parametri

Lezione del 13 ottobre
[59 presenti]

Argomenti trattati:

• funzioni
• passaggio di parametri per valore
  
• passaggio di parametri per riferimento
• passaggio di puntatori
• stack e record di attivazione
  

Podcast della lezione:
http://multicommunity.di.uniroma1.it/podcast/panizziC++20061013.mp3

Codice C++ di esempio realizzato a lezione:

• cubo.cpp
• upcase.cpp
• passaggi.cpp
  
• passpunt.cpp
  

Dispense online:
Funzioni, passaggio di parametri, visibilità, ciclo di vita, stack e record di attivazione

Modularizzazione

Lezione del 10 ottobre
[61 presenti]

Argomenti trattati:

• decomposizione, astrazione
• coesione, interfacciamento esplicito fra moduli, accoppiamento, information hiding
• variabili globali nella modularizzazione
• modularizzazione mediante funzioni
  
• modularizzazione mediante file
  
• modularizzazione mediante tipo astratto
  
• modularizzazione mediante namespace
  

Podcast della lezione:
http://multicommunity.di.uniroma1.it/podcast/panizziC++20061010.mp3

Dispense online:
Modularizzazione

Memoria dinamica

Lezione del 6 ottobre
[34 presenti]

Argomenti trattati:

• memoria dinamica
• variabili ed array allocati dinamicamente
• new, delete
• dichiarazione per riferimento
• stringhe come array di char

Podcast della lezione:
http://multicommunity.di.uniroma1.it/podcast/panizzi6ott2006.mp3

Codice C++ di esempio realizzato a lezione:

• memoria dinamica
• array allocati in memoria dinamica
• riferimenti
• stringhe
  

Dispense online:
Puntatori, memoria dinamica e riferimenti

Puntatori

Lezione del 3 ottobre
[72 presenti]

Argomenti trattati:

• operatore & (address of)
• allocazione di variabili
  
• puntatore, suo tipo
  
• allocazione di variabili puntatore
• operatore di dereferenziazione, come r-value e come l-value
• equivalenza puntatori/nomi di array
• aritmetica dei puntatori

Podcast della lezione:
http://multicommunity.di.uniroma1.it/podcast/panizzi03ott2006.wav

Codice di esempio realizzato a lezione:
puntatori.cpp

Dispense online:
Puntatori, memoria dinamica e riferimenti

Lezione del 29 settembre

[57 presenti]

Argomenti trattati:

• Tipi
• Variabili
• Operatori ed espressioni
• Array
• Strutture di controllo del flusso: if-else, while, for

Podcast della lezione:
http://multicommunity.di.uniroma1.it/podcast/panizzi29sep2006.wav

Prima lezione (26 settembre)

[72 presenti]

Argomenti trattati:

• Introduzione al corso: materiale didattico, sito di riferimento (questo blog) , modalità di esame, etc.
• Struttura di un programma C++
• Compilazione e IDE
• Concetti di tipo e di variabile

Statistiche sui corsi (non più) propedeutici di Programmazione I e II:

Corso	seguito	superato
Programmazione I	70 (97%)	48 (66%)
Programmazione II	37 (51%)	28 (38%)

Orari e materiale didattico

Martedì 16-17
Venerdì 14-16
Aula 1 Fisica nuovo edificio

Materiale didattico:
- Panizzi, Il linguaggio di programmazione C++ (dispense del docente pubblicate su http://multicommunity.di.uniroma1.it)
- Stroustrup, The C++ programming language, 3a ed. Addison-Wesley (esiste anche versione in italiano)
- Eckel, Thinking in C++, reperibile gratuitamente sul sito www.bruceeckel.com
- Cadoli, Fondamenti di progettazione dei programmi, CittàStudi Edizioni, 1997
- Cadoli, Esercizi di progettazione dei programmi in C++, CittàStudi Edizioni, 1998
- Barone et. al, Programmazione Scientifica, Pearson, 2006

Compilatori:
- gnu cc per linux
- Dev-C++ per windows

Esame: progetto a gruppi di 3/4 studenti

Questo blog riguarda il corso di Programmazione a oggetti del Corso di laurea in Tecnologie informatiche dell'Università degli Studi di Roma "La Sapienza".