Programmazione a Oggetti

Appello di settembre

panizzi@uniroma1.it (Emanuele Panizzi) — Mon, 08 Sep 2008 08:08:00 +0000

Il prossimo appello di Programmazione a oggetti è fissato per giovedì 18 settembre, ore 15:00 in aula seminari.
Si prega di prenotarsi sul blog, con un commento a questo post, con almeno una settimana di anticipo.

Orario di ricevimento 2008/2009

panizzi@uniroma1.it (Emanuele Panizzi) — Thu, 04 Sep 2008 09:14:00 +0000

A partire dal 5 settembre, il ricevimento studenti si tiene il venerdì dalle ore 10:00 alle ore 12:00 nel mio studio.

Valutazione del corso da parte degli studenti

panizzi@uniroma1.it (Emanuele Panizzi) — Tue, 22 Jul 2008 17:12:00 +0000

Sono stati pubblicati i dati della valutazione del corso fatta dagli studenti.

Il risultato è molto positivo: alla domanda 31, che riassume il gradimento del corso, sono state date le seguenti risposte:
Quanto è soddisfatto complessivamente di come è stato svolto questo insegnamento?

Questo risultato è molto positivo in assoluto (il 93% degli studenti hanno dichiarato di essere soddisfatti del corso, e in particolare, sufficiente è il voto dato dal 33%, "molto" dal 44% e "del tutto" soddisfatti sono stati il 14% degli studenti).

Inoltre questo corso è uno di quelli che contribuiscono ad alzare la media delle valutazioni degli studenti per tutti i corsi del primo semestre, che vede un totale di soddisfatti dell'85% e uno shift dei voti verso "sufficiente", come mostrato nel grafico qui sotto:

Seguendo i link potete trovare i risultati delle opinioni degli studenti su progaogg e i risultati completi per tutti i corsi del semestre.

Formazione residua gruppi

panizzi@uniroma1.it (Emanuele Panizzi) — Thu, 17 Jul 2008 10:47:00 +0000

Chi ancora non avesse trovato colleghi per formare un gruppo di progetto, può lasciare un commento a questo post.

Appello del 27 giugno 2008

panizzi@uniroma1.it (Emanuele Panizzi) — Mon, 09 Jun 2008 14:05:00 +0000

Il prossimo appello di Programmazione a oggetti è fissato per venerdì 27 giugno, ore 9:30 in sala riunioni.
Si prega di prenotarsi sul blog, con un commento a questo post, con almeno una settimana di anticipo.

Appelli estivi

panizzi@uniroma1.it (Emanuele Panizzi) — Fri, 11 Apr 2008 08:48:00 +0000

Ecco il calendario degli appelli estivi 2008 di Programmazione a Oggetti:

27 giugno, ore 9:30 sala riunioni
17 luglio, ore 9:30 aula alfa
18 settembre, ore 15 aula seminari

Ricevimento studenti

panizzi@uniroma1.it (Emanuele Panizzi) — Mon, 11 Feb 2008 09:57:00 +0000

Il ricevimento studenti di oggi, lunedì 11 febbraio, è annullato.

Appello del 7 febbraio: iscrizioni

panizzi@uniroma1.it (Emanuele Panizzi) — Thu, 24 Jan 2008 18:22:00 +0000

Si prega di iscriversi all'esame mediante un commento a questo post.

L'ISCRIZIONE VA FATTA ENTRO GIOVEDì SERA 1 FEBBRAIO.

Indicare i cognomi dei componenti del gruppo. Se dovete sostenere lo scritto, indicatelo.

L'esame si terrà giovedì 7 febbraio in aula riunioni alle 15:00.

QUESTO APPELLO E' APERTO SOLO AD ALCUNI STUDENTI (IMMATRICOLATI NEGLI ANNI PRECEDENTI). Vedi regole in un post precedente o sul sito del dipartimento www.di.uniroma1.it

Iscrizione all'esame

panizzi@uniroma1.it (Emanuele Panizzi) — Mon, 14 Jan 2008 18:32:00 +0000

Si prega di iscriversi all'esame mediante un commento a questo post o un'email diretta al mio indirizzo.

L'ISCRIZIONE VA FATTA ENTRO MERCOLEDì SERA 16 GENNAIO.

Indicare i cognomi dei componenti del gruppo. Se dovete sostenere lo scritto, indicatelo.

L'esame si terrà mercoledì 23 gennaio in aula riunioni alle 10:00.

Aggiornamento incontri di gennaio

panizzi@uniroma1.it (Emanuele Panizzi) — Mon, 07 Jan 2008 21:49:00 +0000

Gli incontri che potremo fare in questo mese sono al massimo 4, poiché il periodo di preparazione agli esami va dall'8 gennaio al 18 compresi.

Quindi le uniche date utili per il nostro corso sono il 10, il 14 e il 17. Più l'incontro di oggi (che abbiamo fatto considerando erroneamente l'inizio del periodo il 7 anziché l'8) fanno 4.

Ho pertanto rimosso il post relativo al 21 gennaio.

Buon 2008!

panizzi@uniroma1.it (Emanuele Panizzi) — Mon, 31 Dec 2007 17:28:00 +0000

Cari studenti,
auguri di buon anno a tutti!
Emanuele Panizzi

Specifiche dell'esercizio per il progetto di Programmazione a oggetti

panizzi@uniroma1.it (Emanuele Panizzi) — Sun, 30 Dec 2007 17:17:00 +0000

L'esercizio consiste nella progettazione di una serie di classi per modellare un sito web che ospita diversi blog e che avverta gli utenti della pubblicazione di nuovi post nei blog ai quali sono abbonati.

La progettazione deve seguire il design pattern Observer spiegato a lezione.

Durante l'esecuzione del programma saranno rappresentati da opportuni oggetti:
- i blog
- i post
- gli utenti abbonati (subscriber)

L'esercizio deve essere svolto in C++ e nel secondo linguaggio ad oggetti scelto dal gruppo; le specifiche indicate nel seguito devono essere seguite esattamente nella versione C++ e il più fedelmente possibile nel secondo linguaggio, adattandole dove le caratteristiche del linguaggio non permettano di seguirle alla lettera.

Specifiche

1) la classe Blog sarà derivata dalla classe subject descritta nel design pattern. Ogni oggetto della classe Blog sarà caratterizzato da un nome e da un elenco di post; per la versione C++ utilizzare un contenitore della standard library per l'elenco dei post.
2) la classe Blog metterà a disposizione un metodo pubblico NewPost() che permetterà di pubblicare un nuovo post specificandone autore, titolo e testo. Ogni volta che viene pubblicato un nuovo post, sarà invocato il metodo Notify() per permettere agli observer di aggiornare il proprio stato corrispondentemente alla variazione dello stato del blog.
3) lo stato del blog, costituito sostanzialmente dall'elenco dei post pubblicati, sarà rappresentato opportunamente nell'oggetto e sarà osservabile dagli observer invocando uno o più dei seguenti metodi pubblici della classe Blog:
GetName() che restituisce il nome del blog
GetTitle() che restituisce il titolo dell'ultimo post pubblicato
GetText() che restituisce il testo integrale dell'ultimo post pubblicato
GetLine() che restituisce i primi 10 caratteri del testo dell'ultimo post pubblicato
GetAuthor() che restituisce il nome dell'autore dell'ultimo post pubblicato
4) la classe Post sarà caratterizzata da tutti i dati relativi a un post, cioè: autore, titolo, testo. Si tratta di stringhe in tutti e tre i casi.
5) la classe Subscriber è una classe derivata dalla classe observer descritta nel design pattern; ogni oggetto della classe rappresenta un utente che si abbona ad uno o più blog per essere avvisato della pubblicazione di nuovi post; il subscriber è caratterizzato dall'indirizzo di posta elettronica; per effettuare l'abbonamento, si userà il metodo Attach() come descritto nel design pattern
6) poiché esistono subscriber generici e subscriber specifici, è opportuno derivare altre due classi dalla classe Subscriber: le chiamiamo SubsriberG e SubscriberS rispettivamente. Un subscriberG è interessato a tutti i post dei blog ai quali è abbonato, mentre un subscriberS è interessato solamente ai post scritti da un particolare autore;
6a) quando viene invocata la funzione Update() per un SubscriberG è necessario recuperare dal blog:
- il nome del blog stesso
- il titolo del post
- i primi 10 caratteri del testo
- il nome dell'autore
e stampare a schermo il subject e il body di una ipotetica email nella quale si informa l'utente della nuova pubblicazione, riportandone i dati sopra indicati;
6b) quando viene invocata la Update() per un SubscriberS è necessario:
- recuperare dal blog l'autore del post, e, se coincidente con l'autore scelto alla creazione del subscriber:
-recuperare nome blog, titolo post, testo integrale e mostrare a schermo il subject e body della mail ipotetica con questi tre dati
7) Nel main() vanno dichiarati un certo numero di blog e di subscriber generici e specifici, indicando per questi ultimi il nome dell'autore al quale sono interessati; vanno poi abbonati i subscriber ai vari blog; vanno infine creati alcuni post per verificare che i subscriber siano avvisati con le email opportune.

Note:
- la pubblicazione effettiva delle pagine web dei blog non va trattata
- sfruttare il polimorfismo per differenziare il comportamento del subscriber generico da quello del subscriber specifico.
- nomi degli autori, titoli e testi dei post sono da scegliere arbitrariamente ai soli fini dell'esecuzione del programma

Eventuali dettagli non specificati qui possono essere proposti in commenti a questo post. Inserire altresì nei commenti eventuali domande di chiarimento. Risponderò direttamente, ma invito anche gli studenti a rispondere ai commenti dei loro colleghi.

Riferimenti volume GoF

panizzi@uniroma1.it (Emanuele Panizzi) — Fri, 28 Dec 2007 19:21:00 +0000

Ecco i riferimenti del volume sui design pattern:

Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides

Design Patterns
Elements of Reusable Object-Oriented Software

ADDISON-WESLEY, 1995 (19-ma ristampa, Gennaio 2000)
ISBN: 0201633612

Nota: GoF

Lezione di giovedì 17 gennaio

panizzi@uniroma1.it (Emanuele Panizzi) — Fri, 28 Dec 2007 19:15:00 +0000

Lasciare un commento specificando se si è interessati a partecipare a questa lezione o a presentare il lavoro del proprio gruppo.

Lezione di lunedì 14 gennaio

panizzi@uniroma1.it (Emanuele Panizzi) — Fri, 28 Dec 2007 19:14:00 +0000

Lasciare un commento specificando se si è interessati a partecipare a questa lezione o a presentare il lavoro del proprio gruppo.

Aggiornamento di lunedì pomeriggio:

La lezione si è tenuta. Un gruppo ha descritto la realizzazione della parte C++ del progetto. Si è discusso sull'implementazione e sulle soluzioni adottate.
Un altro gruppo ha accennato al lavoro che stanno facendo con il linguaggio PHP, alle strutture del linguaggio utilizzate per realizzare l'esercizio e alle differenze con l'implementazione C++.

Non è stato possibile registrare l'audio della lezione.

Lezione di giovedì 10 gennaio 2008

panizzi@uniroma1.it (Emanuele Panizzi) — Fri, 28 Dec 2007 19:14:00 +0000

Lasciare un commento specificando se si è interessati a partecipare a questa lezione o a presentare il lavoro del proprio gruppo.

Lezione del 7 gennaio 2008

panizzi@uniroma1.it (Emanuele Panizzi) — Fri, 28 Dec 2007 19:12:00 +0000

Lasciare un commento specificando se si è interessati a partecipare a questa lezione o a presentare il lavoro del proprio gruppo.

Aggiornamento (5 gennaio 2008): ALLORA LUNEDI' FACCIAMO L'INCONTRO PER DISCUTERE DELLE DOMANDE CHE AVETE SUL PROGETTO. SI TERRA' REGOLARMENTE ALLE 14 NELLA SOLITA AULA.

Aggiornamento (7 gennaio):
[24 presenti]

Argomenti:

domande e risposte sulla implementazione del pattern in C++
uso di oggetti o di puntatori nei contenitori

Podcast:
registrazione audio dell'incontro

Esercizio del progetto

panizzi@uniroma1.it (Emanuele Panizzi) — Fri, 21 Dec 2007 09:53:00 +0000

Lezione del 20 dicembre 2007 - Ultima lezione del corso
[41 presenti]

Argomenti:

pattern observer: approfondimento e considerazioni
requisiti dell'esercizio da svolgere nei due linguaggi scelti per il progetto
organizzazione per il mese di gennaio (incontri aggiuntivi ed esami):

nel mese di gennaio è possibile fare 5 incontri nello stesso orario delle lezioni;
lo scopo degli incontri è quello di approfondire gli argomenti del corso in relazione al progetto assegnato;
negli incontri, i gruppi di studenti che stanno svolgendo il progetto, su base volontaria, presenteranno il lavoro svolto fino a quel momento; tale presentazione consentirà di effettuare una discussione utile a tutti gli studenti del corso; consentirà anche ai gruppi più attivi di avere una valutazione preventiva del proprio lavoro;
inserirò nel blog 5 post, uno per ogni incontro; per poter svolgere la presentazione, o per partecipare come uditori, inserire un commento su uno dei post;
gli incontri si terranno se e solo se ci sarà un numero sufficiente di uditori e almeno un gruppo presentatore; con un commento finale almeno 24 prima annuncierò se l'incontro si terrà o no;
L'esame si terrà il 23 gennaio, mercoledì, alle 10:00 in aula riunioni a via salaria. Lo svolgimento è il seguente: chi non è esonerato dovrà fare uno scritto a risposta multipla (test) della durata di 20 minuti (15 domande), simile a quello della prova d'esonero; Poi iniziano le discussioni con i gruppi; la correzione dei test dei membri del gruppo non esonerati avverrà contestualmente alla discussione di ogni gruppo.
Lo svolgimento del test e la discussione del progetto sono due cose distinte; un voto positivo in una delle due cose verrà 'salvato' per un anno nei miei file; chi non supera una delle due parti in questo appello potrà tornare a risostenerla nel prossimo appello; la discussione deve però essere svolta congiuntamente da tutti i componenti del gruppo in prima istanza: solo chi è eventualmente 'respinto' dovrà risostenere la discussione autonomamente in un appello successivo

Podcast della lezione:
registrazione audio della lezione

Formazione dei gruppi

panizzi@uniroma1.it (Emanuele Panizzi) — Tue, 18 Dec 2007 11:32:00 +0000

Coloro che cercano persone con cui formare un gruppo per il progetto possono lasciare un commento a questo post indicando:

un proprio riferimento (es. email)
se cercano un gruppo in cui inserirsi o se sono già in 2/3 e cercano un'altra persona
se hanno già scelto un linguaggio (lasciando il commento nel post precedente) o se vorrebbero entrare nel gruppo che ha scelto un particolare linguaggio

Ricordo che i gruppi sono formati almeno da 3 persone e al massimo da 4. Non si può sostenere l'esame singolarmente né in due.

Ogni linguaggio può essere scelto da uno e un solo gruppo.

Design pattern

panizzi@uniroma1.it (Emanuele Panizzi) — Mon, 17 Dec 2007 16:52:00 +0000

Lezione di lunedì 17 dicembre

[35 presenti]

Argomenti:

assegnazione del progetto: spiegazione del post "Progetto"
design pattern, accenni
pattern: Observer

Podcast:
registrazione audio di questa lezione, in formato wav

Polimorfismo

panizzi@uniroma1.it (Emanuele Panizzi) — Mon, 17 Dec 2007 16:42:00 +0000

Lezione di giovedì 13 dicembre

[33 presenti]

Argomenti:

funzioni virtuali
late binding
funzioni virtuali pure
classi base astratte
esempi

Dispense online:
Ereditarietà

Podcast:
registrazione audio di questa lezione, in formato wav

Progetto

panizzi@uniroma1.it (Emanuele Panizzi) — Mon, 17 Dec 2007 12:05:00 +0000

Obiettivo del progetto:
conoscere un altro linguaggio di programmazione ad oggetti, analizzando le somiglianze e le differenze rispetto al C++.

Come svolgerlo:

scegliere un linguaggio tra quelli indicati su wikipedia alla pagina Object-oriented programming language
leggere la descrizione del linguaggio scelto su wikipedia stessa.
approfondire la gestione di alcuni elementi del linguaggio, quali ereditarietà e polimorfismo, così come sono descritti nei siti web principali relativi al linguaggio scelto (i link a tali siti si trovano generalmente su wikipedia)
realizzare un esercizio sia in C++ che nel linguaggio scelto: l'esercizio verrà assegnato in aula e riportato sul blog.

Presentazione:
all'esame è necessario presentare una relazione sul lavoro svolto, sia su supporto cartaceo che digitale. Presentarsi all'esame con il computer portatile.

Discussione:
la discussione all'esame verterà sulle caratteristiche generali del linguaggio scelto paragonate a quelle del C++. Inoltre verrà analizzata l'implementazione dell'esercizio nei due linguaggi.

Gruppi:
di 3/4 persone. Non è necessario comunicare la composizione del gruppo in anticipo. E' necessario però scegliere il linguaggio di programmazione e indicarlo in un commento a questo post: verificare che non sia stato scelto da un altro gruppo prima!

Prenotazioni:
per sostenere l'esame è necessario prenotarsi via email con almeno una settimana di anticipo. Indicare nella mail il nome e cognome di tutti i componenti del gruppo.

Gennaio:
negli incontri di gennaio i gruppi che lo vorranno potranno descrivere il lavoro svolto ai fini di avere chiarimenti e indirizzi per la prosecuzione del progetto. Prenotare la descrizione inserendo un commento al post che inserirò appositamente.

Sui template e i progetti multi-file

panizzi@uniroma1.it (Emanuele Panizzi) — Mon, 10 Dec 2007 20:24:00 +0000

Notate quanto segue:

1) Quando utilizziamo i template nella definizione delle classi, il compilatore non compila effettivamente il codice della classe finché non è necessario.

Se ad esempio dichiariamo la seguente classe:

template
class Coppia
{private:
T1 primo;
T2 secondo;
public:
Coppia(T1,T2);
T1 Primo() const;
T2 Secondo() const;
};

questo codice verrà "conservato" dal compilatore finché non sia necessario compilarlo instanziando i due tipi T1 e T2, ad esempio a seguito dell'istruzione:

Coppia c1(10,2.3);

2) Quando scriviamo un programma C++ siamo soliti dividerlo in più file per questioni di modularizzazione. Tipicamente, la dichiarazione di una classe sta in un file miaclasse.h, mentre la definizione delle sue funzioni proprie sta in un file miaclasse.cpp. Includeremo miaclasse.h in tutti i .cpp del progetto che usano oggetti di quella classe, oltre che in miaclasse.cpp.

3) Ma, se si tratta di una classe modello, cioè dichiarata mediante template, il compilatore non dovrà compilare i metodi definiti in miaclasse.cpp se nessuno li usa. E quindi, non avrebbe senso compilare separatamente il file miaclasse.cpp! (Nella compilazione separata, infatti, il compilatore "non ha memoria" delle compilazioni degli altri file del progetto, e non sa se in qualcuno di questi è stata usata la classe modello)

4) Quindi l'unica via praticabile è quella di includere tutta la classe modello in ogni file .cpp del progetto che vuole usarla. Pertanto (cosa che non si poteva evincere dal file che abbiamo realizzato nella lezione del 22 novembre, template.cpp) dobbiamo scrivere anche le definizioni dei metodi della classe modello in miaclasse.h. Il file miaclasse.cpp -- per le classi modello -- non dobbiamo scriverlo né inserirlo nel progetto.

5) Il linker è in grado automaticamente di identificare la implementazione di tutti i metodi della classe modello e di collegarli alle rispettive chiamate.

Nei file qui sotto potete trovare un esempio di programmino che compila e gira correttamente:

Se provate invece a spostare le definizioni in un nuovo file templcoppia.cpp e ad aggiungere questo file al progetto, vedrete l'errore di linking.

Ereditarietà

panizzi@uniroma1.it (Emanuele Panizzi) — Mon, 10 Dec 2007 19:17:00 +0000

Lezione di lunedì 10 dicembre, 1 ora
[33 presenti]

Argomenti:

ereditarietàesercizio: conto ripetizioni caratteri in una parola

Dispense online:
Ereditarietà

Podcast:
registrazione audio di questa lezione, in formato wav

Foto della lavagna:

Esercitazione: blogger

panizzi@uniroma1.it (Emanuele Panizzi) — Mon, 10 Dec 2007 19:01:00 +0000

Lezioni di: lunedì 3 dicembre, 1 ora e giovedì 6 dicembre, 2 ore

Argomento:

Esercitazione su classi e contenitori. Tema dell'esercitazione:

realizzare un programma per la gestione di un sito che pubblica dei blog.
Ad ogni blog possono abbonarsi dei subscribers che riceveranno una mail ogni volta che verrà pubblicato un nuovo post sul blog.
Modellare mediante opportune classi e metodi.

Podcast:

registrazione audio della lezione di lunedì 3, in formato wav

registrazione audio della lezione di giovedì 6, in formato wav

Codice scritto nelle due lezioni: